ui/base/ime/chromeos/character_composer_unittest.cc

   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 = &gtk_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