← Back to branch summary

~marcobiscaro2112/unity/custom-bg

« back to all changes in this revision

Viewing changes to tests/test_im_text_entry.cpp

  • Committer: Marco Biscaro
  • Date: 2012-07-12 12:05:07 UTC
  • mfrom: (2353.2.144 unity)
  • Revision ID: marcobiscaro2112@gmail.com-20120712120507-7u9sb43bqon88ifl
Merge with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_im_text_entry.cpp
24
24
 
25
25
using namespace testing;
26
26
using namespace unity;
 
27
using namespace nux;
27
28
 
28
29
namespace
29
30
{
48
49
class MockTextEntry : public IMTextEntry
49
50
{
50
51
public:
51
 
  MOCK_METHOD1(InsertText, void(std::string const&));
52
 
  MOCK_METHOD0(Cut, void());
53
 
  MOCK_METHOD0(Copy, void());
54
 
  MOCK_METHOD1(Paste, void(bool));
 
52
  MOCK_METHOD0(CutClipboard, void());
 
53
  MOCK_METHOD0(CopyClipboard, void());
 
54
  MOCK_METHOD0(PasteClipboard, void());
 
55
  MOCK_METHOD0(PastePrimaryClipboard, void());
55
56
 
56
 
  bool TryHandleSpecial(nux::Event const& event)
 
57
  bool InspectKeyEvent(nux::Event const& event)
57
58
  {
58
 
    return IMTextEntry::TryHandleSpecial(event);
 
59
    key_down.emit(event.type, event.GetKeySym(), event.GetKeyState(), nullptr, 0);
 
60
    return IMTextEntry::InspectKeyEvent(event);
59
61
  }
60
62
};
61
63
 
66
68
 
67
69
  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_c);
68
70
 
69
 
  EXPECT_CALL(text_entry, Copy());
70
 
  EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
71
  EXPECT_CALL(text_entry, CopyClipboard());
 
72
  EXPECT_TRUE(text_entry.InspectKeyEvent(event));
71
73
}
72
74
 
73
75
TEST(TestIMTextEntry, CopyCtrlIns)
76
78
 
77
79
  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_INSERT);
78
80
 
79
 
  EXPECT_CALL(text_entry, Copy());
80
 
  EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
81
  EXPECT_CALL(text_entry, CopyClipboard());
 
82
  EXPECT_TRUE(text_entry.InspectKeyEvent(event));
81
83
}
82
84
 
83
85
TEST(TestIMTextEntry, PasteCtrlV)
86
88
 
87
89
  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_v);
88
90
 
89
 
  EXPECT_CALL(text_entry, Paste(false));
90
 
  EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
91
  EXPECT_CALL(text_entry, PasteClipboard());
 
92
  EXPECT_TRUE(text_entry.InspectKeyEvent(event));
91
93
}
92
94
 
93
95
TEST(TestIMTextEntry, PasteShiftIns)
96
98
 
97
99
  TestEvent event(KEY_MODIFIER_SHIFT, NUX_VK_INSERT);
98
100
 
99
 
  EXPECT_CALL(text_entry, Paste(false));
100
 
  EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
101
  EXPECT_CALL(text_entry, PasteClipboard());
 
102
  EXPECT_TRUE(text_entry.InspectKeyEvent(event));
101
103
}
102
104
 
103
105
TEST(TestIMTextEntry, CutCtrlX)
106
108
 
107
109
  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_x);
108
110
 
109
 
  EXPECT_CALL(text_entry, Cut());
110
 
  EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
111
  EXPECT_CALL(text_entry, CutClipboard());
 
112
  EXPECT_TRUE(text_entry.InspectKeyEvent(event));
111
113
}
112
114
 
113
115
TEST(TestIMTextEntry, CutShiftDel)
116
118
 
117
119
  TestEvent event(KEY_MODIFIER_SHIFT, NUX_VK_DELETE);
118
120
 
119
 
  EXPECT_CALL(text_entry, Cut());
120
 
  EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
121
  EXPECT_CALL(text_entry, CutClipboard());
 
122
  EXPECT_TRUE(text_entry.InspectKeyEvent(event));
121
123
}
122
124
 
123
125
TEST(TestIMTextEntry, CtrlMoveKeys)
125
127
  MockTextEntry text_entry;
126
128
 
127
129
  TestEvent left(KEY_MODIFIER_CTRL, NUX_VK_LEFT);
128
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(left));
 
130
  EXPECT_TRUE(text_entry.InspectKeyEvent(left));
129
131
 
130
132
  TestEvent right(KEY_MODIFIER_CTRL, NUX_VK_RIGHT);
131
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(right));
 
133
  EXPECT_TRUE(text_entry.InspectKeyEvent(right));
132
134
 
133
135
  TestEvent home(KEY_MODIFIER_CTRL, NUX_VK_HOME);
134
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(home));
 
136
  EXPECT_TRUE(text_entry.InspectKeyEvent(home));
135
137
 
136
138
  TestEvent end(KEY_MODIFIER_CTRL, NUX_VK_END);
137
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(end));
 
139
  EXPECT_TRUE(text_entry.InspectKeyEvent(end));
138
140
}
139
141
 
140
142
TEST(TestIMTextEntry, CtrlDeleteKeys)
142
144
  MockTextEntry text_entry;
143
145
 
144
146
  TestEvent del(KEY_MODIFIER_CTRL, NUX_VK_DELETE);
145
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(del));
 
147
  EXPECT_TRUE(text_entry.InspectKeyEvent(del));
146
148
 
147
149
  TestEvent backspace(KEY_MODIFIER_CTRL, NUX_VK_BACKSPACE);
148
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(backspace));
 
150
  EXPECT_TRUE(text_entry.InspectKeyEvent(backspace));
149
151
}
150
152
 
151
153
TEST(TestIMTextEntry, CtrlA)
153
155
  MockTextEntry text_entry;
154
156
 
155
157
  TestEvent selectall(KEY_MODIFIER_CTRL, NUX_VK_a);
156
 
  EXPECT_TRUE(text_entry.TryHandleSpecial(selectall));
 
158
  EXPECT_TRUE(text_entry.InspectKeyEvent(selectall));
157
159
}
158
160
 
159
161
TEST(TestIMTextEntry, CtrlKeybindings)
165
167
                                            NUX_VK_HOME, NUX_VK_END,
166
168
                                            NUX_VK_BACKSPACE, NUX_VK_DELETE };
167
169
 
168
 
  for (unsigned long keysym = 0; keysym < XK_VoidSymbol; ++keysym)
 
170
  for (auto keysym : allowed_keys)
169
171
  {
170
 
    bool should_be_handled = false;
171
 
 
172
 
    if (std::find(allowed_keys.begin(), allowed_keys.end(), keysym) != allowed_keys.end())
173
 
      should_be_handled = true;
174
 
 
175
172
    TestEvent event(KEY_MODIFIER_CTRL, keysym);
176
 
    EXPECT_EQ(text_entry.TryHandleSpecial(event), should_be_handled);
 
173
    EXPECT_TRUE(text_entry.InspectKeyEvent(event));
177
174
  }
178
175
}
179
176
 
184
181
  for (unsigned long keysym = 0; keysym < XK_VoidSymbol; ++keysym)
185
182
  {
186
183
    TestEvent event(KEY_MODIFIER_ALT, keysym);
187
 
    EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
184
    EXPECT_FALSE(text_entry.InspectKeyEvent(event));
188
185
  }
189
186
}
190
187
 
195
192
  for (unsigned long keysym = 0; keysym < XK_VoidSymbol; ++keysym)
196
193
  {
197
194
    TestEvent event(KEY_MODIFIER_SUPER, keysym);
198
 
    EXPECT_FALSE(text_entry.TryHandleSpecial(event));
 
195
    EXPECT_FALSE(text_entry.InspectKeyEvent(event));
199
196
  }
200
197
}
201
198