| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/base/ime/chromeos/character_composer.h" | |
| 6 | |
| 7 #include "base/strings/utf_string_conversions.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 #include "third_party/gtk+/gdk/gdkkeysyms.h" | |
| 10 #include "ui/base/glib/glib_integers.h" | |
| 11 #include "ui/events/event_constants.h" | |
| 12 #include "ui/events/keycodes/keyboard_codes.h" | |
| 13 | |
| 14 using base::ASCIIToUTF16; | |
| 15 | |
| 16 namespace ui { | |
| 17 | |
| 18 class CharacterComposerTest : public testing::Test { | |
| 19 protected: | |
| 20 bool FilterKeyPress(CharacterComposer* character_composer, | |
| 21 uint key, | |
| 22 uint keycode, | |
| 23 int flags) { | |
| 24 return character_composer->FilterKeyPressInternal(key, keycode, flags); | |
| 25 } | |
| 26 | |
| 27 // Expects key is not filtered and no character is composed. | |
| 28 void ExpectKeyNotFilteredWithKeyCode(CharacterComposer* character_composer, | |
| 29 uint key, | |
| 30 uint keycode, | |
| 31 int flags) { | |
| 32 EXPECT_FALSE(character_composer->FilterKeyPressInternal(key, keycode, | |
| 33 flags)); | |
| 34 EXPECT_TRUE(character_composer->composed_character().empty()); | |
| 35 } | |
| 36 | |
| 37 // Expects key is filtered and no character is composed. | |
| 38 void ExpectKeyFilteredWithKeycode(CharacterComposer* character_composer, | |
| 39 uint key, | |
| 40 uint keycode, | |
| 41 int flags) { | |
| 42 EXPECT_TRUE(character_composer->FilterKeyPressInternal(key, keycode, | |
| 43 flags)); | |
| 44 EXPECT_TRUE(character_composer->composed_character().empty()); | |
| 45 } | |
| 46 | |
| 47 // Expects key is not filtered and no character is composed. | |
| 48 void ExpectKeyNotFiltered(CharacterComposer* character_composer, | |
| 49 uint key, | |
| 50 int flags) { | |
| 51 ExpectKeyNotFilteredWithKeyCode(character_composer, key, 0, flags); | |
| 52 } | |
| 53 | |
| 54 // Expects key is filtered and no character is composed. | |
| 55 void ExpectKeyFiltered(CharacterComposer* character_composer, | |
| 56 uint key, | |
| 57 int flags) { | |
| 58 ExpectKeyFilteredWithKeycode(character_composer, key, 0, flags); | |
| 59 } | |
| 60 | |
| 61 // Expects |expected_character| is composed after sequence [key1, key2]. | |
| 62 void ExpectCharacterComposed(CharacterComposer* character_composer, | |
| 63 uint key1, | |
| 64 uint key2, | |
| 65 int flags, | |
| 66 const base::string16& expected_character) { | |
| 67 ExpectKeyFiltered(character_composer, key1, flags); | |
| 68 EXPECT_TRUE(character_composer->FilterKeyPressInternal(key2, 0, flags)); | |
| 69 EXPECT_EQ(expected_character, character_composer->composed_character()); | |
| 70 } | |
| 71 | |
| 72 // Expects |expected_character| is composed after sequence [key1, key2, key3]. | |
| 73 void ExpectCharacterComposed(CharacterComposer* character_composer, | |
| 74 uint key1, | |
| 75 uint key2, | |
| 76 uint key3, | |
| 77 int flags, | |
| 78 const base::string16& expected_character) { | |
| 79 ExpectKeyFiltered(character_composer, key1, flags); | |
| 80 ExpectCharacterComposed(character_composer, key2, key3, flags, | |
| 81 expected_character); | |
| 82 } | |
| 83 | |
| 84 // Expects |expected_character| is composed after sequence [key1, key2, key3, | |
| 85 // key 4]. | |
| 86 void ExpectCharacterComposed(CharacterComposer* character_composer, | |
| 87 uint key1, | |
| 88 uint key2, | |
| 89 uint key3, | |
| 90 uint key4, | |
| 91 int flags, | |
| 92 const base::string16& expected_character) { | |
| 93 ExpectKeyFiltered(character_composer, key1, flags); | |
| 94 ExpectCharacterComposed(character_composer, key2, key3, key4, flags, | |
| 95 expected_character); | |
| 96 } | |
| 97 | |
| 98 // Expects |expected_character| is composed after sequence [key1, key2, key3, | |
| 99 // key 4, key5]. | |
| 100 void ExpectCharacterComposed(CharacterComposer* character_composer, | |
| 101 uint key1, | |
| 102 uint key2, | |
| 103 uint key3, | |
| 104 uint key4, | |
| 105 uint key5, | |
| 106 int flags, | |
| 107 const base::string16& expected_character) { | |
| 108 ExpectKeyFiltered(character_composer, key1, flags); | |
| 109 ExpectCharacterComposed(character_composer, key2, key3, key4, key5, flags, | |
| 110 expected_character); | |
| 111 } | |
| 112 | |
| 113 // Expects |expected_character| is composed after sequence [key1, key2, key3, | |
| 114 // key 4, key5, key6]. | |
| 115 void ExpectCharacterComposed(CharacterComposer* character_composer, | |
| 116 uint key1, | |
| 117 uint key2, | |
| 118 uint key3, | |
| 119 uint key4, | |
| 120 uint key5, | |
| 121 uint key6, | |
| 122 int flags, | |
| 123 const base::string16& expected_character) { | |
| 124 ExpectKeyFiltered(character_composer, key1, flags); | |
| 125 ExpectCharacterComposed(character_composer, key2, key3, key4, key5, key6, | |
| 126 flags, expected_character); | |
| 127 } | |
| 128 | |
| 129 // Expects |expected_character| is composed after sequence [{key1, keycode1}]. | |
| 130 void ExpectCharacterComposedWithKeyCode( | |
| 131 CharacterComposer* character_composer, | |
| 132 uint key1, uint keycode1, | |
| 133 int flags, | |
| 134 const base::string16& expected_character) { | |
| 135 EXPECT_TRUE(character_composer->FilterKeyPressInternal(key1, keycode1, | |
| 136 flags)); | |
| 137 EXPECT_EQ(expected_character, character_composer->composed_character()); | |
| 138 } | |
| 139 }; | |
| 140 | |
| 141 TEST_F(CharacterComposerTest, InitialState) { | |
| 142 CharacterComposer character_composer; | |
| 143 EXPECT_TRUE(character_composer.composed_character().empty()); | |
| 144 } | |
| 145 | |
| 146 TEST_F(CharacterComposerTest, NormalKeyIsNotFiltered) { | |
| 147 CharacterComposer character_composer; | |
| 148 ExpectKeyNotFiltered(&character_composer, GDK_KEY_B, 0); | |
| 149 ExpectKeyNotFiltered(&character_composer, GDK_KEY_Z, 0); | |
| 150 ExpectKeyNotFiltered(&character_composer, GDK_KEY_c, 0); | |
| 151 ExpectKeyNotFiltered(&character_composer, GDK_KEY_m, 0); | |
| 152 ExpectKeyNotFiltered(&character_composer, GDK_KEY_0, 0); | |
| 153 ExpectKeyNotFiltered(&character_composer, GDK_KEY_1, 0); | |
| 154 ExpectKeyNotFiltered(&character_composer, GDK_KEY_8, 0); | |
| 155 } | |
| 156 | |
| 157 TEST_F(CharacterComposerTest, PartiallyMatchingSequence) { | |
| 158 CharacterComposer character_composer; | |
| 159 | |
| 160 // Composition with sequence ['dead acute', '1'] will fail. | |
| 161 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0); | |
| 162 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 163 | |
| 164 // Composition with sequence ['dead acute', 'dead circumflex', '1'] will fail. | |
| 165 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0); | |
| 166 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_circumflex, 0); | |
| 167 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 168 } | |
| 169 | |
| 170 TEST_F(CharacterComposerTest, FullyMatchingSequences) { | |
| 171 CharacterComposer character_composer; | |
| 172 // LATIN SMALL LETTER A WITH ACUTE | |
| 173 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_a, 0, | |
| 174 base::string16(1, 0x00E1)); | |
| 175 // LATIN CAPITAL LETTER A WITH ACUTE | |
| 176 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_A, 0, | |
| 177 base::string16(1, 0x00C1)); | |
| 178 // GRAVE ACCENT | |
| 179 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_grave, | |
| 180 GDK_KEY_dead_grave, 0, base::string16(1, 0x0060)); | |
| 181 // LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE | |
| 182 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, | |
| 183 GDK_KEY_dead_circumflex, GDK_KEY_a, 0, | |
| 184 base::string16(1, 0x1EA5)); | |
| 185 // LATIN CAPITAL LETTER U WITH HORN AND GRAVE | |
| 186 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_grave, | |
| 187 GDK_KEY_dead_horn, GDK_KEY_U, 0, | |
| 188 base::string16(1, 0x1EEA)); | |
| 189 // LATIN CAPITAL LETTER C WITH CEDILLA | |
| 190 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_C, 0, | |
| 191 base::string16(1, 0x00C7)); | |
| 192 // LATIN SMALL LETTER C WITH CEDILLA | |
| 193 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_c, 0, | |
| 194 base::string16(1, 0x00E7)); | |
| 195 } | |
| 196 | |
| 197 TEST_F(CharacterComposerTest, FullyMatchingSequencesAfterMatchingFailure) { | |
| 198 CharacterComposer character_composer; | |
| 199 // Composition with sequence ['dead acute', 'dead circumflex', '1'] will fail. | |
| 200 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0); | |
| 201 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_circumflex, 0); | |
| 202 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 203 // LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE | |
| 204 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, | |
| 205 GDK_KEY_dead_circumflex, GDK_KEY_a, 0, | |
| 206 base::string16(1, 0x1EA5)); | |
| 207 } | |
| 208 | |
| 209 TEST_F(CharacterComposerTest, ComposedCharacterIsClearedAfterReset) { | |
| 210 CharacterComposer character_composer; | |
| 211 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_a, 0, | |
| 212 base::string16(1, 0x00E1)); | |
| 213 character_composer.Reset(); | |
| 214 EXPECT_TRUE(character_composer.composed_character().empty()); | |
| 215 } | |
| 216 | |
| 217 TEST_F(CharacterComposerTest, CompositionStateIsClearedAfterReset) { | |
| 218 CharacterComposer character_composer; | |
| 219 // Even though sequence ['dead acute', 'a'] will compose 'a with acute', | |
| 220 // no character is composed here because of reset. | |
| 221 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0); | |
| 222 character_composer.Reset(); | |
| 223 ExpectKeyNotFiltered(&character_composer, GDK_KEY_a, 0); | |
| 224 } | |
| 225 | |
| 226 TEST_F(CharacterComposerTest, KeySequenceCompositionPreedit) { | |
| 227 CharacterComposer character_composer; | |
| 228 // LATIN SMALL LETTER A WITH ACUTE | |
| 229 // preedit_string() is always empty in key sequence composition mode. | |
| 230 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0); | |
| 231 EXPECT_TRUE(character_composer.preedit_string().empty()); | |
| 232 EXPECT_TRUE(FilterKeyPress(&character_composer, GDK_KEY_a, 0, 0)); | |
| 233 EXPECT_EQ(base::string16(1, 0x00E1), character_composer.composed_character()); | |
| 234 EXPECT_TRUE(character_composer.preedit_string().empty()); | |
| 235 } | |
| 236 | |
| 237 // ComposeCheckerWithCompactTable in character_composer.cc is depending on the | |
| 238 // assumption that the data in gtkimcontextsimpleseqs.h is correctly ordered. | |
| 239 TEST_F(CharacterComposerTest, MainTableIsCorrectlyOrdered) { | |
| 240 // This file is included here intentionally, instead of the top of the file, | |
| 241 // because including this file at the top of the file will define a | |
| 242 // global constant and contaminate the global namespace. | |
| 243 #include "third_party/gtk+/gtk/gtkimcontextsimpleseqs.h" | |
| 244 const int index_size = 26; | |
| 245 const int index_stride = 6; | |
| 246 | |
| 247 // Verify that the index is correctly ordered | |
| 248 for (int i = 1; i < index_size; ++i) { | |
| 249 const int index_key_prev = gtk_compose_seqs_compact[(i - 1)*index_stride]; | |
| 250 const int index_key = gtk_compose_seqs_compact[i*index_stride]; | |
| 251 EXPECT_TRUE(index_key > index_key_prev); | |
| 252 } | |
| 253 | |
| 254 // Verify that the sequenes are correctly ordered | |
| 255 struct { | |
| 256 int operator()(const uint16* l, const uint16* r, int length) const{ | |
| 257 for (int i = 0; i < length; ++i) { | |
| 258 if (l[i] > r[i]) | |
| 259 return 1; | |
| 260 if (l[i] < r[i]) | |
| 261 return -1; | |
| 262 } | |
| 263 return 0; | |
| 264 } | |
| 265 } compare_sequence; | |
| 266 | |
| 267 for (int i = 0; i < index_size; ++i) { | |
| 268 for (int length = 1; length < index_stride - 1; ++length) { | |
| 269 const int index_begin = gtk_compose_seqs_compact[i*index_stride + length]; | |
| 270 const int index_end = | |
| 271 gtk_compose_seqs_compact[i*index_stride + length + 1]; | |
| 272 const int stride = length + 1; | |
| 273 for (int index = index_begin + stride; index < index_end; | |
| 274 index += stride) { | |
| 275 const uint16* sequence = >k_compose_seqs_compact[index]; | |
| 276 const uint16* sequence_prev = sequence - stride; | |
| 277 EXPECT_EQ(1, compare_sequence(sequence, sequence_prev, length)); | |
| 278 } | |
| 279 } | |
| 280 } | |
| 281 } | |
| 282 | |
| 283 TEST_F(CharacterComposerTest, HexadecimalComposition) { | |
| 284 CharacterComposer character_composer; | |
| 285 // HIRAGANA LETTER A (U+3042) | |
| 286 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 287 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 288 ExpectCharacterComposed(&character_composer, GDK_KEY_3, GDK_KEY_0, GDK_KEY_4, | |
| 289 GDK_KEY_2, GDK_KEY_space, 0, | |
| 290 base::string16(1, 0x3042)); | |
| 291 // MUSICAL KEYBOARD (U+1F3B9) | |
| 292 const base::char16 kMusicalKeyboard[] = {0xd83c, 0xdfb9}; | |
| 293 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 294 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 295 ExpectCharacterComposed(&character_composer, GDK_KEY_1, GDK_KEY_f, GDK_KEY_3, | |
| 296 GDK_KEY_b, GDK_KEY_9, GDK_KEY_Return, 0, | |
| 297 base::string16(kMusicalKeyboard, | |
| 298 kMusicalKeyboard + | |
| 299 arraysize(kMusicalKeyboard))); | |
| 300 } | |
| 301 | |
| 302 TEST_F(CharacterComposerTest, HexadecimalCompositionPreedit) { | |
| 303 CharacterComposer character_composer; | |
| 304 // HIRAGANA LETTER A (U+3042) | |
| 305 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 306 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 307 EXPECT_EQ(ASCIIToUTF16("u"), character_composer.preedit_string()); | |
| 308 ExpectKeyFiltered(&character_composer, GDK_KEY_3, 0); | |
| 309 EXPECT_EQ(ASCIIToUTF16("u3"), character_composer.preedit_string()); | |
| 310 ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0); | |
| 311 EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string()); | |
| 312 ExpectKeyFiltered(&character_composer, GDK_KEY_4, 0); | |
| 313 EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string()); | |
| 314 ExpectKeyFiltered(&character_composer, GDK_KEY_a, 0); | |
| 315 EXPECT_EQ(ASCIIToUTF16("u304a"), character_composer.preedit_string()); | |
| 316 ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0); | |
| 317 EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string()); | |
| 318 ExpectCharacterComposed(&character_composer, GDK_KEY_2, GDK_KEY_Return, 0, | |
| 319 base::string16(1, 0x3042)); | |
| 320 EXPECT_EQ(ASCIIToUTF16(""), character_composer.preedit_string()); | |
| 321 | |
| 322 // Sequence with an ignored character ('x') and Escape. | |
| 323 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 324 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 325 EXPECT_EQ(ASCIIToUTF16("u"), character_composer.preedit_string()); | |
| 326 ExpectKeyFiltered(&character_composer, GDK_KEY_3, 0); | |
| 327 EXPECT_EQ(ASCIIToUTF16("u3"), character_composer.preedit_string()); | |
| 328 ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0); | |
| 329 EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string()); | |
| 330 ExpectKeyFiltered(&character_composer, GDK_KEY_x, 0); | |
| 331 EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string()); | |
| 332 ExpectKeyFiltered(&character_composer, GDK_KEY_4, 0); | |
| 333 EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string()); | |
| 334 ExpectKeyFiltered(&character_composer, GDK_KEY_2, 0); | |
| 335 EXPECT_EQ(ASCIIToUTF16("u3042"), character_composer.preedit_string()); | |
| 336 ExpectKeyFiltered(&character_composer, GDK_KEY_Escape, 0); | |
| 337 EXPECT_EQ(ASCIIToUTF16(""), character_composer.preedit_string()); | |
| 338 } | |
| 339 | |
| 340 TEST_F(CharacterComposerTest, HexadecimalCompositionWithNonHexKey) { | |
| 341 CharacterComposer character_composer; | |
| 342 | |
| 343 // Sequence [Ctrl+Shift+U, x, space] does not compose a character. | |
| 344 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 345 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 346 ExpectKeyFiltered(&character_composer, GDK_KEY_x, 0); | |
| 347 ExpectKeyFiltered(&character_composer, GDK_KEY_space, 0); | |
| 348 EXPECT_TRUE(character_composer.composed_character().empty()); | |
| 349 | |
| 350 // HIRAGANA LETTER A (U+3042) with a sequence [3, 0, x, 4, 2]. | |
| 351 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 352 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 353 ExpectCharacterComposed(&character_composer, GDK_KEY_3, GDK_KEY_0, GDK_KEY_x, | |
| 354 GDK_KEY_4, GDK_KEY_2, GDK_KEY_space, 0, | |
| 355 base::string16(1, 0x3042)); | |
| 356 } | |
| 357 | |
| 358 TEST_F(CharacterComposerTest, HexadecimalCompositionWithAdditionalModifiers) { | |
| 359 CharacterComposer character_composer; | |
| 360 | |
| 361 // Ctrl+Shift+Alt+U | |
| 362 // HIRAGANA LETTER A (U+3042) | |
| 363 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 364 EF_SHIFT_DOWN | EF_CONTROL_DOWN | EF_ALT_DOWN); | |
| 365 ExpectCharacterComposed(&character_composer, GDK_KEY_3, GDK_KEY_0, GDK_KEY_4, | |
| 366 GDK_KEY_2, GDK_KEY_space, 0, | |
| 367 base::string16(1, 0x3042)); | |
| 368 | |
| 369 // Ctrl+Shift+u (CapsLock enabled) | |
| 370 ExpectKeyNotFiltered(&character_composer, GDK_KEY_u, | |
| 371 EF_SHIFT_DOWN | EF_CONTROL_DOWN | EF_CAPS_LOCK_DOWN); | |
| 372 } | |
| 373 | |
| 374 TEST_F(CharacterComposerTest, CancelHexadecimalComposition) { | |
| 375 CharacterComposer character_composer; | |
| 376 // Cancel composition with ESC. | |
| 377 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 378 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 379 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 380 ExpectKeyFiltered(&character_composer, GDK_KEY_Escape, 0); | |
| 381 | |
| 382 // Now we can start composition again since the last composition was | |
| 383 // cancelled. | |
| 384 // HIRAGANA LETTER A (U+3042) | |
| 385 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 386 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 387 ExpectCharacterComposed(&character_composer, GDK_KEY_3, GDK_KEY_0, GDK_KEY_4, | |
| 388 GDK_KEY_2, GDK_KEY_space, 0, | |
| 389 base::string16(1, 0x3042)); | |
| 390 } | |
| 391 | |
| 392 TEST_F(CharacterComposerTest, HexadecimalCompositionWithBackspace) { | |
| 393 CharacterComposer character_composer; | |
| 394 // HIRAGANA LETTER A (U+3042) | |
| 395 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 396 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 397 ExpectKeyFiltered(&character_composer, GDK_KEY_3, 0); | |
| 398 ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0); | |
| 399 ExpectKeyFiltered(&character_composer, GDK_KEY_f, 0); | |
| 400 ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0); | |
| 401 ExpectCharacterComposed(&character_composer, GDK_KEY_4, GDK_KEY_2, | |
| 402 GDK_KEY_space, 0, base::string16(1, 0x3042)); | |
| 403 } | |
| 404 | |
| 405 TEST_F(CharacterComposerTest, CancelHexadecimalCompositionWithBackspace) { | |
| 406 CharacterComposer character_composer; | |
| 407 | |
| 408 // Backspace just after Ctrl+Shift+U. | |
| 409 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 410 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 411 ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0); | |
| 412 ExpectKeyNotFiltered(&character_composer, GDK_KEY_3, 0); | |
| 413 | |
| 414 // Backspace twice after Ctrl+Shift+U and 3. | |
| 415 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 416 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 417 ExpectKeyFiltered(&character_composer, GDK_KEY_3, 0); | |
| 418 ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0); | |
| 419 ExpectKeyFiltered(&character_composer, GDK_KEY_BackSpace, 0); | |
| 420 ExpectKeyNotFiltered(&character_composer, GDK_KEY_3, 0); | |
| 421 } | |
| 422 | |
| 423 TEST_F(CharacterComposerTest, HexadecimalCompositionPreeditWithModifierPressed) | |
| 424 { | |
| 425 // This test case supposes X Window System uses 101 keyboard layout. | |
| 426 CharacterComposer character_composer; | |
| 427 const int control_shift = EF_CONTROL_DOWN | EF_SHIFT_DOWN; | |
| 428 // HIRAGANA LETTER A (U+3042) | |
| 429 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 430 GDK_KEY_U, ui::VKEY_U, control_shift); | |
| 431 EXPECT_EQ(ASCIIToUTF16("u"), character_composer.preedit_string()); | |
| 432 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 433 GDK_KEY_numbersign, ui::VKEY_3, control_shift); | |
| 434 EXPECT_EQ(ASCIIToUTF16("u3"), character_composer.preedit_string()); | |
| 435 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 436 GDK_KEY_parenright, ui::VKEY_0, control_shift); | |
| 437 EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string()); | |
| 438 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 439 GDK_KEY_dollar, ui::VKEY_4, control_shift); | |
| 440 EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string()); | |
| 441 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 442 GDK_KEY_A, ui::VKEY_A, control_shift); | |
| 443 EXPECT_EQ(ASCIIToUTF16("u304a"), character_composer.preedit_string()); | |
| 444 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 445 GDK_KEY_BackSpace, ui::VKEY_BACK, control_shift); | |
| 446 EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string()); | |
| 447 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 448 GDK_KEY_at, ui::VKEY_2, control_shift); | |
| 449 EXPECT_EQ(ASCIIToUTF16("u3042"), character_composer.preedit_string()); | |
| 450 ExpectCharacterComposedWithKeyCode(&character_composer, | |
| 451 GDK_KEY_Return, ui::VKEY_RETURN, | |
| 452 control_shift, | |
| 453 base::string16(1, 0x3042)); | |
| 454 EXPECT_EQ(ASCIIToUTF16(""), character_composer.preedit_string()); | |
| 455 | |
| 456 // Sequence with an ignored character (control + shift + 'x') and Escape. | |
| 457 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 458 GDK_KEY_U, ui::VKEY_U, control_shift); | |
| 459 EXPECT_EQ(ASCIIToUTF16("u"), character_composer.preedit_string()); | |
| 460 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 461 GDK_KEY_numbersign, ui::VKEY_3, control_shift); | |
| 462 EXPECT_EQ(ASCIIToUTF16("u3"), character_composer.preedit_string()); | |
| 463 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 464 GDK_KEY_parenright, ui::VKEY_0, control_shift); | |
| 465 EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string()); | |
| 466 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 467 GDK_KEY_X, ui::VKEY_X, control_shift); | |
| 468 EXPECT_EQ(ASCIIToUTF16("u30"), character_composer.preedit_string()); | |
| 469 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 470 GDK_KEY_dollar, ui::VKEY_4, control_shift); | |
| 471 EXPECT_EQ(ASCIIToUTF16("u304"), character_composer.preedit_string()); | |
| 472 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 473 GDK_KEY_at, ui::VKEY_2, control_shift); | |
| 474 EXPECT_EQ(ASCIIToUTF16("u3042"), character_composer.preedit_string()); | |
| 475 ExpectKeyFilteredWithKeycode(&character_composer, | |
| 476 GDK_KEY_Escape, ui::VKEY_ESCAPE, control_shift); | |
| 477 EXPECT_EQ(ASCIIToUTF16(""), character_composer.preedit_string()); | |
| 478 } | |
| 479 | |
| 480 TEST_F(CharacterComposerTest, InvalidHexadecimalSequence) { | |
| 481 CharacterComposer character_composer; | |
| 482 // U+FFFFFFFF | |
| 483 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 484 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 485 for (int i = 0; i < 8; ++i) | |
| 486 ExpectKeyFiltered(&character_composer, GDK_KEY_f, 0); | |
| 487 ExpectKeyFiltered(&character_composer, GDK_KEY_space, 0); | |
| 488 | |
| 489 // U+0000 (Actually, this is a valid unicode character, but we don't | |
| 490 // compose a string with a character '\0') | |
| 491 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 492 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 493 for (int i = 0; i < 4; ++i) | |
| 494 ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0); | |
| 495 ExpectKeyFiltered(&character_composer, GDK_KEY_space, 0); | |
| 496 | |
| 497 // U+10FFFF | |
| 498 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 499 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 500 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 501 ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0); | |
| 502 for (int i = 0; i < 4; ++i) | |
| 503 ExpectKeyFiltered(&character_composer, GDK_KEY_f, 0); | |
| 504 ExpectKeyFiltered(&character_composer, GDK_KEY_space, 0); | |
| 505 | |
| 506 // U+110000 | |
| 507 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 508 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 509 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 510 ExpectKeyFiltered(&character_composer, GDK_KEY_1, 0); | |
| 511 for (int i = 0; i < 4; ++i) | |
| 512 ExpectKeyFiltered(&character_composer, GDK_KEY_0, 0); | |
| 513 ExpectKeyFiltered(&character_composer, GDK_KEY_space, 0); | |
| 514 } | |
| 515 | |
| 516 TEST_F(CharacterComposerTest, HexadecimalSequenceAndDeadKey) { | |
| 517 CharacterComposer character_composer; | |
| 518 // LATIN SMALL LETTER A WITH ACUTE | |
| 519 ExpectCharacterComposed(&character_composer, GDK_KEY_dead_acute, GDK_KEY_a, 0, | |
| 520 base::string16(1, 0x00E1)); | |
| 521 // HIRAGANA LETTER A (U+3042) with dead_acute ignored. | |
| 522 ExpectKeyFiltered(&character_composer, GDK_KEY_U, | |
| 523 EF_SHIFT_DOWN | EF_CONTROL_DOWN); | |
| 524 ExpectCharacterComposed(&character_composer, GDK_KEY_3, GDK_KEY_0, | |
| 525 GDK_KEY_dead_acute, GDK_KEY_4, GDK_KEY_2, | |
| 526 GDK_KEY_space, 0, base::string16(1, 0x3042)); | |
| 527 // LATIN CAPITAL LETTER U WITH ACUTE while 'U' is pressed with Ctrl+Shift. | |
| 528 ExpectKeyFiltered(&character_composer, GDK_KEY_dead_acute, 0); | |
| 529 EXPECT_TRUE(FilterKeyPress(&character_composer, GDK_KEY_U, 0, | |
| 530 EF_SHIFT_DOWN | EF_CONTROL_DOWN)); | |
| 531 EXPECT_EQ(base::string16(1, 0x00DA), character_composer.composed_character()); | |
| 532 } | |
| 533 | |
| 534 TEST_F(CharacterComposerTest, BlacklistedKeyeventsTest) { | |
| 535 CharacterComposer character_composer; | |
| 536 EXPECT_TRUE(FilterKeyPress(&character_composer, GDK_KEY_dead_acute, 0, 0)); | |
| 537 EXPECT_FALSE(FilterKeyPress(&character_composer, GDK_KEY_s, 0, 0)); | |
| 538 ASSERT_EQ(1U, character_composer.composed_character().size()); | |
| 539 EXPECT_EQ(GDK_KEY_apostrophe, character_composer.composed_character().at(0)); | |
| 540 } | |
| 541 | |
| 542 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
