← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to session/session_test.cc

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
session/session_test.cc
78
78
  }
79
79
  return preedit;
80
80
}
 
81
 
 
82
void InitSessionToPrecomposition(Session* session) {
 
83
#ifdef OS_WINDOWS
 
84
  // Session is created with direct mode on Windows
 
85
  // Direct status
 
86
  commands::Command command;
 
87
  session->IMEOn(&command);
 
88
#endif  // OS_WINDOWS
 
89
}
81
90
}  // namespace
82
91
 
83
92
class SessionTest : public testing::Test {
86
95
    config::ConfigHandler::GetConfig(&default_config_);
87
96
    Util::SetUserProfileDirectory(FLAGS_test_tmpdir);
88
97
    convertermock_.reset(new ConverterMock());
89
 
    ConverterInterface::SetConverter(convertermock_.get());
 
98
    ConverterFactory::SetConverter(convertermock_.get());
90
99
    Util::SetUserProfileDirectory(FLAGS_test_tmpdir);
91
100
 
92
101
    handler_.reset(new SessionHandler());
156
165
 
157
166
TEST_F(SessionTest, TestSendKey) {
158
167
  scoped_ptr<Session> session(handler_->NewSession());
 
168
  InitSessionToPrecomposition(session.get());
159
169
 
160
170
  commands::Command command;
161
171
 
203
213
 
204
214
TEST_F(SessionTest, SendCommand) {
205
215
  scoped_ptr<Session> session(handler_->NewSession());
 
216
  InitSessionToPrecomposition(session.get());
206
217
 
207
218
  commands::Command command;
208
219
  InsertCharacterChars("kanji", session.get(), &command);
263
274
TEST_F(SessionTest, SwitchInputMode) {
264
275
  {
265
276
    scoped_ptr<Session> session(handler_->NewSession());
 
277
    InitSessionToPrecomposition(session.get());
266
278
    commands::Command command;
267
279
 
268
280
    // SWITCH_INPUT_MODE
299
311
    // Confirm that we can change the mode from DIRECT
300
312
    // to other modes directly (without IMEOn command).
301
313
    scoped_ptr<Session> session(handler_->NewSession());
 
314
    InitSessionToPrecomposition(session.get());
302
315
    commands::Command command;
303
316
    session->IMEOff(&command);
304
317
 
346
359
TEST_F(SessionTest, RevertComposition) {
347
360
  // Issue#2237323
348
361
  scoped_ptr<Session> session(handler_->NewSession());
 
362
  InitSessionToPrecomposition(session.get());
349
363
  commands::Command command;
350
364
 
351
365
  InsertCharacterChars("aiueo", session.get(), &command);
376
390
 
377
391
TEST_F(SessionTest, InputMode) {
378
392
  scoped_ptr<Session> session(handler_->NewSession());
 
393
  InitSessionToPrecomposition(session.get());
379
394
  commands::Command command;
380
395
  EXPECT_TRUE(session->InputModeHalfASCII(&command));
 
396
  EXPECT_TRUE(command.output().consumed());
381
397
  EXPECT_EQ(mozc::commands::HALF_ASCII, command.output().mode());
382
398
 
383
399
  SendKey("a", session.get(), &command);
394
410
 
395
411
TEST_F(SessionTest, SelectCandidate) {
396
412
  scoped_ptr<Session> session(handler_->NewSession());
 
413
  InitSessionToPrecomposition(session.get());
397
414
 
398
415
  commands::Command command;
399
416
  InsertCharacterChars("aiueo", session.get(), &command);
424
441
 
425
442
TEST_F(SessionTest, HighlightCandidate) {
426
443
  scoped_ptr<Session> session(handler_->NewSession());
 
444
  InitSessionToPrecomposition(session.get());
427
445
 
428
446
  commands::Command command;
429
447
  InsertCharacterChars("aiueo", session.get(), &command);
454
472
 
455
473
TEST_F(SessionTest, Conversion) {
456
474
  scoped_ptr<Session> session(handler_->NewSession());
 
475
  InitSessionToPrecomposition(session.get());
457
476
 
458
477
  commands::Command command;
459
478
  InsertCharacterChars("aiueo", session.get(), &command);
495
514
 
496
515
TEST_F(SessionTest, SegmentWidthShrink) {
497
516
  scoped_ptr<Session> session(handler_->NewSession());
 
517
  InitSessionToPrecomposition(session.get());
498
518
 
499
519
  commands::Command command;
500
520
  InsertCharacterChars("aiueo", session.get(), &command);
517
537
 
518
538
TEST_F(SessionTest, ConvertPrev) {
519
539
  scoped_ptr<Session> session(handler_->NewSession());
 
540
  InitSessionToPrecomposition(session.get());
520
541
 
521
542
  commands::Command command;
522
543
  InsertCharacterChars("aiueo", session.get(), &command);
546
567
  Segment *segment;
547
568
  Segment::Candidate *candidate;
548
569
  scoped_ptr<Session> session(handler_->NewSession());
 
570
  InitSessionToPrecomposition(session.get());
549
571
 
550
572
  commands::Command command;
551
573
  InsertCharacterChars("watasinonamaehanakanodesu", session.get(), &command);
668
690
  Segment *segment;
669
691
  Segment::Candidate *candidate;
670
692
  scoped_ptr<Session> session(handler_->NewSession());
 
693
  InitSessionToPrecomposition(session.get());
671
694
 
672
695
  commands::Command command;
673
696
  InsertCharacterChars("ai", session.get(), &command);
762
785
  Segment *segment;
763
786
  Segment::Candidate *candidate;
764
787
  scoped_ptr<Session> session(handler_->NewSession());
 
788
  InitSessionToPrecomposition(session.get());
765
789
 
766
790
  commands::Command command;
767
791
  InsertCharacterChars("bariniryokouniitta", session.get(), &command);
851
875
 
852
876
  // Issue#1560608
853
877
  scoped_ptr<Session> session(handler_->NewSession());
 
878
  InitSessionToPrecomposition(session.get());
854
879
 
855
880
  commands::Command command;
856
881
  InsertCharacterChars("watasinonamae", session.get(), &command);
910
935
  Segment *segment;
911
936
  Segment::Candidate *candidate;
912
937
  scoped_ptr<Session> session(handler_->NewSession());
 
938
  InitSessionToPrecomposition(session.get());
913
939
 
914
940
  commands::Command command;
915
941
  InsertCharacterChars("watasinohaha", session.get(), &command);
969
995
  Segment *segment;
970
996
  Segment::Candidate *candidate;
971
997
  scoped_ptr<Session> session(handler_->NewSession());
 
998
  InitSessionToPrecomposition(session.get());
972
999
  commands::Command command;
973
1000
  InsertCharacterChars("jishin", session.get(), &command);
974
1001
 
1020
1047
  Segment::Candidate *candidate;
1021
1048
 
1022
1049
  scoped_ptr<Session> session(handler_->NewSession());
 
1050
  InitSessionToPrecomposition(session.get());
1023
1051
  commands::Command command;
1024
1052
  InsertCharacterChars("jishin", session.get(), &command);
1025
1053
 
1061
1089
 
1062
1090
TEST_F(SessionTest, ConvertToHalfWidth) {
1063
1091
  scoped_ptr<Session> session(handler_->NewSession());
 
1092
  InitSessionToPrecomposition(session.get());
1064
1093
  commands::Command command;
1065
1094
  InsertCharacterChars("abc", session.get(), &command);
1066
1095
 
1103
1132
  Segment::Candidate *candidate;
1104
1133
 
1105
1134
  scoped_ptr<Session> session(handler_->NewSession());
 
1135
  InitSessionToPrecomposition(session.get());
1106
1136
  commands::Command command;
1107
1137
  InsertCharacterChars("dvd", session.get(), &command);
1108
1138
 
1163
1193
  Segment::Candidate *candidate;
1164
1194
 
1165
1195
  scoped_ptr<Session> session(handler_->NewSession());
 
1196
  InitSessionToPrecomposition(session.get());
1166
1197
  command.Clear();
1167
1198
  InsertCharacterChars("dvd", session.get(), &command);
1168
1199
 
1211
1242
TEST_F(SessionTest, SwitchKanaType) {
1212
1243
  {  // From composition mode.
1213
1244
    scoped_ptr<Session> session(handler_->NewSession());
 
1245
    InitSessionToPrecomposition(session.get());
1214
1246
    commands::Command command;
1215
1247
    InsertCharacterChars("abc", session.get(), &command);
1216
1248
 
1267
1299
 
1268
1300
  {  // From conversion mode.
1269
1301
    scoped_ptr<Session> session(handler_->NewSession());
 
1302
    InitSessionToPrecomposition(session.get());
1270
1303
    commands::Command command;
1271
1304
    InsertCharacterChars("kanji", session.get(), &command);
1272
1305
 
1334
1367
 
1335
1368
TEST_F(SessionTest, TranslateHalfWidth) {
1336
1369
  scoped_ptr<Session> session(handler_->NewSession());
 
1370
  InitSessionToPrecomposition(session.get());
1337
1371
  commands::Command command;
1338
1372
  InsertCharacterChars("abc", session.get(), &command);
1339
1373
 
1362
1396
 
1363
1397
TEST_F(SessionTest, UpdatePreferences) {
1364
1398
  scoped_ptr<Session> session(handler_->NewSession());
 
1399
  InitSessionToPrecomposition(session.get());
1365
1400
  commands::Command command;
1366
1401
  InsertCharacterChars("aiueo", session.get(), &command);
1367
1402
  Segments segments;
1409
1444
  scoped_ptr<keymap::KeyMapManager> keymap(new keymap::KeyMapManager());
1410
1445
 
1411
1446
  scoped_ptr<Session> session(new Session(&table,
1412
 
                                          ConverterInterface::GetConverter(),
 
1447
                                          ConverterFactory::GetConverter(),
1413
1448
                                          keymap.get()));
 
1449
  InitSessionToPrecomposition(session.get());
1414
1450
 
1415
1451
  commands::Command command;
1416
1452
  InsertCharacterChars("pan", session.get(), &command);
1455
1491
  scoped_ptr<keymap::KeyMapManager> keymap(new keymap::KeyMapManager());
1456
1492
 
1457
1493
  scoped_ptr<Session> session(new Session(&table,
1458
 
                                          ConverterInterface::GetConverter(),
 
1494
                                          ConverterFactory::GetConverter(),
1459
1495
                                          keymap.get()));
 
1496
  InitSessionToPrecomposition(session.get());
1460
1497
 
1461
1498
  commands::Command command;
1462
1499
  command.mutable_input()->mutable_key()->set_key_code('m');
1511
1548
  Segment *segment;
1512
1549
  Segment::Candidate *candidate;
1513
1550
  scoped_ptr<Session> session(handler_->NewSession());
 
1551
  InitSessionToPrecomposition(session.get());
1514
1552
  commands::Command command;
1515
1553
 
1516
1554
  const string exceeded_preedit(500, 'a');
1547
1585
  Segment *segment;
1548
1586
  Segment::Candidate *candidate;
1549
1587
  scoped_ptr<Session> session(handler_->NewSession());
 
1588
  InitSessionToPrecomposition(session.get());
1550
1589
 
1551
1590
  commands::Command command;
1552
1591
  InsertCharacterChars("watasinonamae", session.get(), &command);
1601
1640
  Segment *segment;
1602
1641
  Segment::Candidate *candidate;
1603
1642
  scoped_ptr<Session> session(handler_->NewSession());
 
1643
  InitSessionToPrecomposition(session.get());
1604
1644
 
1605
1645
  commands::Command command;
1606
1646
  InsertCharacterChars("kamabokonoinbou", session.get(), &command);
1668
1708
  ASSERT_EQ(config::Config::SHORTCUT_123456789, GET_CONFIG(selection_shortcut));
1669
1709
 
1670
1710
  scoped_ptr<Session> session(handler_->NewSession());
 
1711
  InitSessionToPrecomposition(session.get());
1671
1712
  session->ReloadConfig();
1672
1713
 
1673
1714
  Segments segments;
1690
1731
 
1691
1732
TEST_F(SessionTest, NumpadKey) {
1692
1733
  scoped_ptr<Session> session(handler_->NewSession());
 
1734
  InitSessionToPrecomposition(session.get());
1693
1735
  commands::Command command;
1694
1736
 
1695
1737
  config::Config config;
1843
1885
  ASSERT_EQ(config::Config::CORNER_BRACKET_SLASH, GET_CONFIG(symbol_method));
1844
1886
 
1845
1887
  scoped_ptr<Session> session(handler_->NewSession());
 
1888
  InitSessionToPrecomposition(session.get());
1846
1889
  session->ReloadConfig();
1847
1890
 
1848
1891
  {
1878
1921
TEST_F(SessionTest, InsertCharacterWithShiftKey) {
1879
1922
  {  // Basic behavior
1880
1923
    scoped_ptr<Session> session(handler_->NewSession());
 
1924
    InitSessionToPrecomposition(session.get());
1881
1925
    commands::Command command;
1882
1926
    EXPECT_TRUE(SendKey("a", session.get(), &command));
1883
1927
    EXPECT_TRUE(SendKey("A", session.get(), &command));  // "あA"
1895
1939
 
1896
1940
  {  // Revert back to the previous input mode.
1897
1941
    scoped_ptr<Session> session(handler_->NewSession());
 
1942
    InitSessionToPrecomposition(session.get());
1898
1943
    commands::Command command;
1899
1944
    session->InputModeFullKatakana(&command);
1900
1945
    EXPECT_EQ(commands::FULL_KATAKANA, command.output().mode());
1944
1989
  }
1945
1990
 
1946
1991
  scoped_ptr<Session> session(handler_->NewSession());
 
1992
  InitSessionToPrecomposition(session.get());
1947
1993
  commands::Command command;
1948
1994
  SendKey("M", session.get(), &command);
1949
1995
 
2033
2079
 
2034
2080
TEST_F(SessionTest, ToggleAlphanumericMode) {
2035
2081
  scoped_ptr<Session> session(handler_->NewSession());
 
2082
  InitSessionToPrecomposition(session.get());
2036
2083
  commands::Command command;
2037
2084
 
2038
2085
  {
2138
2185
 
2139
2186
TEST_F(SessionTest, InsertSpaceHalfWidth) {
2140
2187
  scoped_ptr<Session> session(handler_->NewSession());
 
2188
  InitSessionToPrecomposition(session.get());
2141
2189
  commands::Command command;
2142
2190
 
2143
2191
  EXPECT_TRUE(session->InsertSpaceHalfWidth(&command));
2173
2221
 
2174
2222
TEST_F(SessionTest, InsertSpaceFullWidth) {
2175
2223
  scoped_ptr<Session> session(handler_->NewSession());
 
2224
  InitSessionToPrecomposition(session.get());
2176
2225
  commands::Command command;
2177
2226
 
2178
2227
  EXPECT_TRUE(session->InsertSpaceFullWidth(&command));
2210
2259
 
2211
2260
TEST_F(SessionTest, InsertSpaceFullWidthOnHalfKanaInput) {
2212
2261
  scoped_ptr<Session> session(handler_->NewSession());
 
2262
  InitSessionToPrecomposition(session.get());
2213
2263
  commands::Command command;
2214
2264
 
2215
2265
  EXPECT_TRUE(session->InputModeHalfKatakana(&command));
2228
2278
  // This is a unittest against http://b/1951385
2229
2279
  Segments segments;
2230
2280
  scoped_ptr<Session> session(handler_->NewSession());
 
2281
  InitSessionToPrecomposition(session.get());
2231
2282
  commands::Command command;
2232
2283
 
2233
2284
  const string exceeded_preedit(500, 'a');
2265
2316
  convertermock_->SetStartPrediction(&segments, true);
2266
2317
 
2267
2318
  scoped_ptr<Session> session(handler_->NewSession());
 
2319
  InitSessionToPrecomposition(session.get());
2268
2320
  commands::Command command;
2269
2321
  EXPECT_TRUE(session->SegmentWidthShrink(&command));
2270
2322
 
2281
2333
TEST_F(SessionTest, Issue1975771) {
2282
2334
  // This is a unittest against http://b/1975771
2283
2335
  scoped_ptr<Session> session(handler_->NewSession());
 
2336
  InitSessionToPrecomposition(session.get());
2284
2337
 
2285
2338
  // Trigger suggest by pressing "a".
2286
2339
  Segments segments;
2322
2375
  // did not check if the current status is in conversion or
2323
2376
  // precomposition.
2324
2377
  scoped_ptr<Session> session(handler_->NewSession());
 
2378
  InitSessionToPrecomposition(session.get());
2325
2379
 
2326
2380
  // "a"
2327
2381
  commands::Command command;
2353
2407
  // The composition should have been reset if CommitSegment submitted
2354
2408
  // the all segments (e.g. the size of segments is one).
2355
2409
  scoped_ptr<Session> session(handler_->NewSession());
 
2410
  InitSessionToPrecomposition(session.get());
2356
2411
  commands::Command command;
2357
2412
  InsertCharacterChars("mozu", session.get(), &command);
2358
2413
 
2382
2437
TEST_F(SessionTest, Issue2026354) {
2383
2438
  // This is a unittest against http://b/2026354
2384
2439
  scoped_ptr<Session> session(handler_->NewSession());
 
2440
  InitSessionToPrecomposition(session.get());
2385
2441
 
2386
2442
  commands::Command command;
2387
2443
  InsertCharacterChars("aiueo", session.get(), &command);
2410
2466
  Segment *segment;
2411
2467
  Segment::Candidate *candidate;
2412
2468
  scoped_ptr<Session> session(handler_->NewSession());
 
2469
  InitSessionToPrecomposition(session.get());
2413
2470
 
2414
2471
  segment = segments.add_segment();
2415
2472
  segment->set_key("a");
2438
2495
TEST_F(SessionTest, Issue2187132) {
2439
2496
  // This is a unittest against http://b/2187132
2440
2497
  scoped_ptr<Session> session(handler_->NewSession());
 
2498
  InitSessionToPrecomposition(session.get());
2441
2499
  commands::Command command;
2442
2500
 
2443
2501
  // Shift + Ascii triggers temporary input mode switch.
2470
2528
  ASSERT_EQ(config::Config::KANA, GET_CONFIG(preedit_method));
2471
2529
 
2472
2530
  scoped_ptr<Session> session(handler_->NewSession());
 
2531
  InitSessionToPrecomposition(session.get());
2473
2532
  session->ReloadConfig();
2474
2533
 
2475
2534
  commands::Command command;
2492
2551
TEST_F(SessionTest, Issue1556649) {
2493
2552
  // This is a unittest against http://b/1556649
2494
2553
  scoped_ptr<Session> session(handler_->NewSession());
 
2554
  InitSessionToPrecomposition(session.get());
2495
2555
  commands::Command command;
2496
2556
  InsertCharacterChars("kudoudesu", session.get(), &command);
2497
2557
  // "くどうです"
2519
2579
  // - Can't input space in ascii mode.
2520
2580
  {
2521
2581
    scoped_ptr<Session> session(handler_->NewSession());
 
2582
    InitSessionToPrecomposition(session.get());
2522
2583
    commands::Command command;
2523
2584
    EXPECT_TRUE(SendKey("a", session.get(), &command));
2524
2585
    command.Clear();
2534
2595
 
2535
2596
  {
2536
2597
    scoped_ptr<Session> session(handler_->NewSession());
 
2598
    InitSessionToPrecomposition(session.get());
2537
2599
    commands::Command command;
2538
2600
    EXPECT_TRUE(SendKey("a", session.get(), &command));
2539
2601
    EXPECT_TRUE(SendKey("I", session.get(), &command));
2550
2612
  // This is a unittest against http://b/1571043.
2551
2613
  // - Underline of composition is separated.
2552
2614
  scoped_ptr<Session> session(handler_->NewSession());
 
2615
  InitSessionToPrecomposition(session.get());
2553
2616
  commands::Command command;
2554
2617
  InsertCharacterChars("aiu", session.get(), &command);
2555
2618
  // "あいう"
2567
2630
  // This is a unittest against http://b/1571043.
2568
2631
  // - ConvertToHiragana converts Vu to U+3094 "ゔ"
2569
2632
  scoped_ptr<Session> session(handler_->NewSession());
 
2633
  InitSessionToPrecomposition(session.get());
2570
2634
  commands::Command command;
2571
2635
  InsertCharacterChars("ravu", session.get(), &command);
2572
2636
  // TODO(komatsu) "ゔ" might be preferred on Mac.
2598
2662
  // Temporary direct input mode through a special sequence such as
2599
2663
  // www. continues even after committing them
2600
2664
  scoped_ptr<Session> session(handler_->NewSession());
 
2665
  InitSessionToPrecomposition(session.get());
2601
2666
  commands::Command command;
2602
2667
  InsertCharacterChars("www.", session.get(), &command);
2603
2668
  EXPECT_EQ("www.", GetComposition(command));
2613
2678
  // Input mode does not recover like MS-IME by single shift key down
2614
2679
  // and up.
2615
2680
  scoped_ptr<Session> session(handler_->NewSession());
 
2681
  InitSessionToPrecomposition(session.get());
2616
2682
  commands::Command command;
2617
2683
  SendKey("G", session.get(), &command);
2618
2684
  EXPECT_EQ("G", GetComposition(command));
2628
2694
  // This is a unittest against http://b/2223762.
2629
2695
  // - The first space in half-width alphanumeric mode is full-width.
2630
2696
  scoped_ptr<Session> session(handler_->NewSession());
 
2697
  InitSessionToPrecomposition(session.get());
2631
2698
  commands::Command command;
2632
2699
 
2633
2700
  EXPECT_TRUE(session->InputModeHalfASCII(&command));
2645
2712
 
2646
2713
  {  // DisplayAsFullKatakana
2647
2714
    scoped_ptr<Session> session(handler_->NewSession());
 
2715
    InitSessionToPrecomposition(session.get());
2648
2716
    commands::Command command;
2649
2717
 
2650
2718
    EXPECT_TRUE(SendKey("a", session.get(), &command));
2665
2733
 
2666
2734
  {  // ConvertToFullKatakana
2667
2735
    scoped_ptr<Session> session(handler_->NewSession());
 
2736
    InitSessionToPrecomposition(session.get());
2668
2737
    commands::Command command;
2669
2738
 
2670
2739
    EXPECT_TRUE(SendKey("a", session.get(), &command));
2703
2772
  // - Temporary input mode should not be overridden by a permanent
2704
2773
  //   input mode change.
2705
2774
  scoped_ptr<Session> session(handler_->NewSession());
 
2775
  InitSessionToPrecomposition(session.get());
2706
2776
  commands::Command command;
2707
2777
 
2708
2778
  EXPECT_TRUE(SendKey("G", session.get(), &command));
2721
2791
  // A temporary input mode remains when a composition is canceled.
2722
2792
  {
2723
2793
    scoped_ptr<Session> session(handler_->NewSession());
 
2794
    InitSessionToPrecomposition(session.get());
2724
2795
    commands::Command command;
2725
2796
 
2726
2797
    EXPECT_TRUE(SendKey("G", session.get(), &command));
2732
2803
 
2733
2804
  {
2734
2805
    scoped_ptr<Session> session(handler_->NewSession());
 
2806
    InitSessionToPrecomposition(session.get());
2735
2807
    commands::Command command;
2736
2808
 
2737
2809
    EXPECT_TRUE(SendKey("G", session.get(), &command));
2755
2827
  handler_->EvalCommand(&command);
2756
2828
 
2757
2829
  scoped_ptr<Session> session(handler_->NewSession());
 
2830
  InitSessionToPrecomposition(session.get());
2758
2831
  ASSERT_EQ(config::Config::MSIME, GET_CONFIG(session_keymap));
2759
2832
 
2760
2833
  EXPECT_TRUE(SendKey("Ctrl Space", session.get(), &command));
2765
2838
  // This is a unittest against http://b/2379374.
2766
2839
  // Numpad ignores Direct input style when typing after conversion.
2767
2840
  scoped_ptr<Session> session(handler_->NewSession());
 
2841
  InitSessionToPrecomposition(session.get());
2768
2842
  commands::Command command;
2769
2843
 
2770
2844
  {  // Set numpad_character_form with NUMPAD_DIRECT_INPUT
2818
2892
  // previous input mode.
2819
2893
  {
2820
2894
    scoped_ptr<Session> session(handler_->NewSession());
 
2895
    InitSessionToPrecomposition(session.get());
2821
2896
    commands::Command command;
2822
2897
 
2823
2898
    InsertCharacterChars("google", session.get(), &command);
2832
2907
 
2833
2908
  {
2834
2909
    scoped_ptr<Session> session(handler_->NewSession());
 
2910
    InitSessionToPrecomposition(session.get());
2835
2911
    commands::Command command;
2836
2912
 
2837
2913
    InsertCharacterChars("Google", session.get(), &command);
2845
2921
 
2846
2922
  {
2847
2923
    scoped_ptr<Session> session(handler_->NewSession());
 
2924
    InitSessionToPrecomposition(session.get());
2848
2925
    commands::Command command;
2849
2926
 
2850
2927
    InsertCharacterChars("Google", session.get(), &command);
2862
2939
 
2863
2940
  {
2864
2941
    scoped_ptr<Session> session(handler_->NewSession());
 
2942
    InitSessionToPrecomposition(session.get());
2865
2943
    commands::Command command;
2866
2944
 
2867
2945
    InsertCharacterChars("http", session.get(), &command);
2874
2952
  }
2875
2953
}
2876
2954
 
2877
 
TEST_F(SessionTest, Isue2555503) {
 
2955
TEST_F(SessionTest, Issue2555503) {
2878
2956
  // This is a unittest against http://b/2555503.
2879
2957
  // Mode respects the previous character too much.
2880
2958
 
2881
2959
  scoped_ptr<Session> session(handler_->NewSession());
 
2960
  InitSessionToPrecomposition(session.get());
2882
2961
  commands::Command command;
2883
2962
  SendKey("a", session.get(), &command);
2884
2963
 
2895
2974
  EXPECT_EQ(commands::FULL_KATAKANA, command.output().mode());
2896
2975
}
2897
2976
 
 
2977
TEST_F(SessionTest, Issue2791640) {
 
2978
  // This is a unittest against http://b/2791640.
 
2979
  // Existing preedit should be committed when IME is turned off.
 
2980
 
 
2981
  scoped_ptr<Session> session(handler_->NewSession());
 
2982
  InitSessionToPrecomposition(session.get());
 
2983
 
 
2984
  commands::Command command;
 
2985
  SendKey("a", session.get(), &command);
 
2986
 
 
2987
  command.Clear();
 
2988
 
 
2989
  SendKey("hankaku/zenkaku", session.get(), &command);
 
2990
 
 
2991
  ASSERT_TRUE(command.output().consumed());
 
2992
 
 
2993
  ASSERT_TRUE(command.output().has_result());
 
2994
  // "あ"
 
2995
  EXPECT_EQ("\xE3\x81\x82", command.output().result().value());
 
2996
  EXPECT_EQ(commands::DIRECT, command.output().mode());
 
2997
 
 
2998
  ASSERT_FALSE(command.output().has_preedit());
 
2999
}
 
3000
 
 
3001
TEST_F(SessionTest, CommitExistingPreeditWhenIMEIsTurnedOff) {
 
3002
  // Existing preedit should be committed when IME is turned off.
 
3003
 
 
3004
  // Check "hankaku/zenkaku"
 
3005
  {
 
3006
    scoped_ptr<Session> session(handler_->NewSession());
 
3007
    InitSessionToPrecomposition(session.get());
 
3008
 
 
3009
    commands::Command command;
 
3010
    SendKey("a", session.get(), &command);
 
3011
 
 
3012
    command.Clear();
 
3013
 
 
3014
    SendKey("hankaku/zenkaku", session.get(), &command);
 
3015
 
 
3016
    ASSERT_TRUE(command.output().consumed());
 
3017
 
 
3018
    ASSERT_TRUE(command.output().has_result());
 
3019
    // "あ"
 
3020
    EXPECT_EQ("\xE3\x81\x82", command.output().result().value());
 
3021
    EXPECT_EQ(commands::DIRECT, command.output().mode());
 
3022
 
 
3023
    ASSERT_FALSE(command.output().has_preedit());
 
3024
  }
 
3025
 
 
3026
  // Check "kanji"
 
3027
  {
 
3028
    scoped_ptr<Session> session(handler_->NewSession());
 
3029
    InitSessionToPrecomposition(session.get());
 
3030
 
 
3031
    commands::Command command;
 
3032
    SendKey("a", session.get(), &command);
 
3033
 
 
3034
    command.Clear();
 
3035
 
 
3036
    SendKey("kanji", session.get(), &command);
 
3037
 
 
3038
    ASSERT_TRUE(command.output().consumed());
 
3039
 
 
3040
    ASSERT_TRUE(command.output().has_result());
 
3041
    // "あ"
 
3042
    EXPECT_EQ("\xE3\x81\x82", command.output().result().value());
 
3043
    EXPECT_EQ(commands::DIRECT, command.output().mode());
 
3044
 
 
3045
    ASSERT_FALSE(command.output().has_preedit());
 
3046
  }
 
3047
}
 
3048
 
 
3049
 
 
3050
TEST_F(SessionTest, SendKeyDirectInputStateTest) {
 
3051
  // InputModeChange commands from direct mode are supported only for Windows
 
3052
  // for now.
 
3053
#ifdef OS_WINDOWS
 
3054
  scoped_ptr<Session> session(handler_->NewSession());
 
3055
  InitSessionToPrecomposition(session.get());
 
3056
  commands::Command command;
 
3057
  session->IMEOff(&command);
 
3058
 
 
3059
  config::Config config;
 
3060
  config::ConfigHandler::GetConfig(&config);
 
3061
  const string custom_keymap_table =
 
3062
      "status\tkey\tcommand\n"
 
3063
      "DirectInput\tHiragana\tInputModeHiragana\n";
 
3064
  config.set_session_keymap(config::Config::CUSTOM);
 
3065
  config.set_custom_keymap_table(custom_keymap_table);
 
3066
  config::ConfigHandler::SetConfig(config);
 
3067
 
 
3068
  session->ReloadConfig();
 
3069
 
 
3070
  command.Clear();
 
3071
  EXPECT_TRUE(SendKey("Hiragana", session.get(), &command));
 
3072
  SendKey("a", session.get(), &command);
 
3073
  EXPECT_TRUE(command.output().has_preedit());
 
3074
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3075
  // "あ"
 
3076
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3077
#endif  // OS_WINDOWS
 
3078
}
 
3079
 
 
3080
TEST_F(SessionTest, IMEOnWithModeTest) {
 
3081
  {
 
3082
    scoped_ptr<Session> session(handler_->NewSession());
 
3083
    InitSessionToPrecomposition(session.get());
 
3084
    commands::Command command;
 
3085
    session->IMEOff(&command);
 
3086
    command.Clear();
 
3087
    command.mutable_input()->mutable_key()->set_mode(
 
3088
        commands::HIRAGANA);
 
3089
    EXPECT_TRUE(session->IMEOn(&command));
 
3090
    EXPECT_TRUE(command.output().has_consumed());
 
3091
    EXPECT_TRUE(command.output().consumed());
 
3092
    EXPECT_TRUE(command.output().has_mode());
 
3093
    EXPECT_EQ(commands::HIRAGANA,
 
3094
              command.output().mode());
 
3095
    SendKey("a", session.get(), &command);
 
3096
    EXPECT_TRUE(command.output().has_preedit());
 
3097
    EXPECT_EQ(1, command.output().preedit().segment_size());
 
3098
    // "あ"
 
3099
    EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3100
  }
 
3101
  {
 
3102
    scoped_ptr<Session> session(handler_->NewSession());
 
3103
    InitSessionToPrecomposition(session.get());
 
3104
    commands::Command command;
 
3105
    session->IMEOff(&command);
 
3106
    command.Clear();
 
3107
    command.mutable_input()->mutable_key()->set_mode(
 
3108
        commands::FULL_KATAKANA);
 
3109
    EXPECT_TRUE(session->IMEOn(&command));
 
3110
    EXPECT_TRUE(command.output().has_mode());
 
3111
    EXPECT_EQ(commands::FULL_KATAKANA,
 
3112
              command.output().mode());
 
3113
    SendKey("a", session.get(), &command);
 
3114
    EXPECT_TRUE(command.output().has_preedit());
 
3115
    EXPECT_EQ(1, command.output().preedit().segment_size());
 
3116
    // "ア"
 
3117
    EXPECT_EQ("\xE3\x82\xA2", command.output().preedit().segment(0).key());
 
3118
  }
 
3119
  {
 
3120
    scoped_ptr<Session> session(handler_->NewSession());
 
3121
    InitSessionToPrecomposition(session.get());
 
3122
    commands::Command command;
 
3123
    session->IMEOff(&command);
 
3124
    command.Clear();
 
3125
    command.mutable_input()->mutable_key()->set_mode(
 
3126
        commands::HALF_KATAKANA);
 
3127
    EXPECT_TRUE(session->IMEOn(&command));
 
3128
    EXPECT_TRUE(command.output().has_mode());
 
3129
    EXPECT_EQ(commands::HALF_KATAKANA,
 
3130
              command.output().mode());
 
3131
    SendKey("a", session.get(), &command);
 
3132
    EXPECT_TRUE(command.output().has_preedit());
 
3133
    EXPECT_EQ(1, command.output().preedit().segment_size());
 
3134
    // "ｱ" (half-width Katakana)
 
3135
    EXPECT_EQ("\xEF\xBD\xB1", command.output().preedit().segment(0).key());
 
3136
  }
 
3137
  {
 
3138
    scoped_ptr<Session> session(handler_->NewSession());
 
3139
    InitSessionToPrecomposition(session.get());
 
3140
    commands::Command command;
 
3141
    session->IMEOff(&command);
 
3142
    command.Clear();
 
3143
    command.mutable_input()->mutable_key()->set_mode(
 
3144
        commands::FULL_ASCII);
 
3145
    EXPECT_TRUE(session->IMEOn(&command));
 
3146
    EXPECT_TRUE(command.output().has_mode());
 
3147
    EXPECT_EQ(commands::FULL_ASCII,
 
3148
              command.output().mode());
 
3149
    SendKey("a", session.get(), &command);
 
3150
    EXPECT_TRUE(command.output().has_preedit());
 
3151
    EXPECT_EQ(1, command.output().preedit().segment_size());
 
3152
    // "ａ"
 
3153
    EXPECT_EQ("\xEF\xBD\x81", command.output().preedit().segment(0).key());
 
3154
  }
 
3155
  {
 
3156
    scoped_ptr<Session> session(handler_->NewSession());
 
3157
    InitSessionToPrecomposition(session.get());
 
3158
    commands::Command command;
 
3159
    session->IMEOff(&command);
 
3160
    command.Clear();
 
3161
    command.mutable_input()->mutable_key()->set_mode(
 
3162
        commands::HALF_ASCII);
 
3163
    EXPECT_TRUE(session->IMEOn(&command));
 
3164
    EXPECT_TRUE(command.output().has_mode());
 
3165
    EXPECT_EQ(commands::HALF_ASCII,
 
3166
              command.output().mode());
 
3167
    SendKey("a", session.get(), &command);
 
3168
    EXPECT_TRUE(command.output().has_preedit());
 
3169
    EXPECT_EQ(1, command.output().preedit().segment_size());
 
3170
    // "a"
 
3171
    EXPECT_EQ("a", command.output().preedit().segment(0).key());
 
3172
  }
 
3173
}
 
3174
 
 
3175
TEST_F(SessionTest, InputModeConsumed) {
 
3176
  scoped_ptr<Session> session(handler_->NewSession());
 
3177
  InitSessionToPrecomposition(session.get());
 
3178
  commands::Command command;
 
3179
  EXPECT_TRUE(session->InputModeHiragana(&command));
 
3180
  EXPECT_TRUE(command.output().consumed());
 
3181
  EXPECT_EQ(mozc::commands::HIRAGANA, command.output().mode());
 
3182
  command.Clear();
 
3183
  EXPECT_TRUE(session->InputModeFullKatakana(&command));
 
3184
  EXPECT_TRUE(command.output().consumed());
 
3185
  EXPECT_EQ(mozc::commands::FULL_KATAKANA, command.output().mode());
 
3186
  command.Clear();
 
3187
  EXPECT_TRUE(session->InputModeHalfKatakana(&command));
 
3188
  EXPECT_TRUE(command.output().consumed());
 
3189
  EXPECT_EQ(mozc::commands::HALF_KATAKANA, command.output().mode());
 
3190
  command.Clear();
 
3191
  EXPECT_TRUE(session->InputModeFullASCII(&command));
 
3192
  EXPECT_TRUE(command.output().consumed());
 
3193
  EXPECT_EQ(mozc::commands::FULL_ASCII, command.output().mode());
 
3194
  command.Clear();
 
3195
  EXPECT_TRUE(session->InputModeHalfASCII(&command));
 
3196
  EXPECT_TRUE(command.output().consumed());
 
3197
  EXPECT_EQ(mozc::commands::HALF_ASCII, command.output().mode());
 
3198
}
 
3199
 
 
3200
TEST_F(SessionTest, InputModeConsumedForTestSendKey) {
 
3201
  // This test is only for Windows, because InputModeHiragana bound
 
3202
  // with Hiragana key is only supported on Windows yet.
 
3203
#ifdef OS_WINDOWS
 
3204
  config::Config config;
 
3205
  config::ConfigHandler::GetConfig(&config);
 
3206
  config.set_session_keymap(config::Config::MSIME);
 
3207
  config::ConfigHandler::SetConfig(config);
 
3208
 
 
3209
  scoped_ptr<Session> session(handler_->NewSession());
 
3210
  InitSessionToPrecomposition(session.get());
 
3211
  ASSERT_EQ(config::Config::MSIME, GET_CONFIG(session_keymap));
 
3212
  // In MSIME keymap, Hiragana is assigned for
 
3213
  // ImputModeHiragana in Precomposition.
 
3214
 
 
3215
  commands::Command command;
 
3216
  EXPECT_TRUE(TestSendKey("Hiragana", session.get(), &command));
 
3217
  EXPECT_TRUE(command.output().consumed());
 
3218
#endif  // OS_WINDOWS
 
3219
}
 
3220
 
 
3221
TEST_F(SessionTest, InputModeOutputHasComposition) {
 
3222
  scoped_ptr<Session> session(handler_->NewSession());
 
3223
  InitSessionToPrecomposition(session.get());
 
3224
  commands::Command command;
 
3225
  SendKey("a", session.get(), &command);
 
3226
  EXPECT_TRUE(command.output().has_preedit());
 
3227
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3228
  // "あ"
 
3229
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3230
 
 
3231
  command.Clear();
 
3232
  EXPECT_TRUE(session->InputModeHiragana(&command));
 
3233
  EXPECT_TRUE(command.output().consumed());
 
3234
  EXPECT_EQ(mozc::commands::HIRAGANA, command.output().mode());
 
3235
  EXPECT_TRUE(command.output().has_preedit());
 
3236
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3237
  // "あ"
 
3238
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3239
 
 
3240
  command.Clear();
 
3241
  EXPECT_TRUE(session->InputModeFullKatakana(&command));
 
3242
  EXPECT_TRUE(command.output().consumed());
 
3243
  EXPECT_EQ(mozc::commands::FULL_KATAKANA, command.output().mode());
 
3244
  EXPECT_TRUE(command.output().has_preedit());
 
3245
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3246
  // "あ"
 
3247
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3248
 
 
3249
  command.Clear();
 
3250
  EXPECT_TRUE(session->InputModeHalfKatakana(&command));
 
3251
  EXPECT_TRUE(command.output().consumed());
 
3252
  EXPECT_EQ(mozc::commands::HALF_KATAKANA, command.output().mode());
 
3253
  EXPECT_TRUE(command.output().has_preedit());
 
3254
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3255
  // "あ"
 
3256
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3257
 
 
3258
  command.Clear();
 
3259
  EXPECT_TRUE(session->InputModeFullASCII(&command));
 
3260
  EXPECT_TRUE(command.output().consumed());
 
3261
  EXPECT_EQ(mozc::commands::FULL_ASCII, command.output().mode());
 
3262
  EXPECT_TRUE(command.output().has_preedit());
 
3263
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3264
  // "あ"
 
3265
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3266
 
 
3267
  command.Clear();
 
3268
  EXPECT_TRUE(session->InputModeHalfASCII(&command));
 
3269
  EXPECT_TRUE(command.output().consumed());
 
3270
  EXPECT_EQ(mozc::commands::HALF_ASCII, command.output().mode());
 
3271
  EXPECT_TRUE(command.output().has_preedit());
 
3272
  EXPECT_EQ(1, command.output().preedit().segment_size());
 
3273
  // "あ"
 
3274
  EXPECT_EQ("\xE3\x81\x82", command.output().preedit().segment(0).key());
 
3275
}
 
3276
 
 
3277
TEST_F(SessionTest, InputModeOutputHasCandidates) {
 
3278
  scoped_ptr<Session> session(handler_->NewSession());
 
3279
  InitSessionToPrecomposition(session.get());
 
3280
 
 
3281
  Segments segments;
 
3282
  SetAiueo(&segments);
 
3283
  convertermock_->SetStartConversion(&segments, true);
 
3284
 
 
3285
  commands::Command command;
 
3286
  InsertCharacterChars("aiueo", session.get(), &command);
 
3287
 
 
3288
  command.Clear();
 
3289
  session->Convert(&command);
 
3290
  session->ConvertNext(&command);
 
3291
  EXPECT_TRUE(command.output().has_candidates());
 
3292
  EXPECT_TRUE(command.output().has_preedit());
 
3293
 
 
3294
  command.Clear();
 
3295
  EXPECT_TRUE(session->InputModeHiragana(&command));
 
3296
  EXPECT_TRUE(command.output().consumed());
 
3297
  EXPECT_EQ(mozc::commands::HIRAGANA, command.output().mode());
 
3298
  EXPECT_TRUE(command.output().has_candidates());
 
3299
  EXPECT_TRUE(command.output().has_preedit());
 
3300
 
 
3301
  command.Clear();
 
3302
  EXPECT_TRUE(session->InputModeFullKatakana(&command));
 
3303
  EXPECT_TRUE(command.output().consumed());
 
3304
  EXPECT_EQ(mozc::commands::FULL_KATAKANA, command.output().mode());
 
3305
  EXPECT_TRUE(command.output().has_candidates());
 
3306
  EXPECT_TRUE(command.output().has_preedit());
 
3307
 
 
3308
  command.Clear();
 
3309
  EXPECT_TRUE(session->InputModeHalfKatakana(&command));
 
3310
  EXPECT_TRUE(command.output().consumed());
 
3311
  EXPECT_EQ(mozc::commands::HALF_KATAKANA, command.output().mode());
 
3312
  EXPECT_TRUE(command.output().has_candidates());
 
3313
  EXPECT_TRUE(command.output().has_preedit());
 
3314
 
 
3315
  command.Clear();
 
3316
  EXPECT_TRUE(session->InputModeFullASCII(&command));
 
3317
  EXPECT_TRUE(command.output().consumed());
 
3318
  EXPECT_EQ(mozc::commands::FULL_ASCII, command.output().mode());
 
3319
  EXPECT_TRUE(command.output().has_candidates());
 
3320
  EXPECT_TRUE(command.output().has_preedit());
 
3321
 
 
3322
  command.Clear();
 
3323
  EXPECT_TRUE(session->InputModeHalfASCII(&command));
 
3324
  EXPECT_TRUE(command.output().consumed());
 
3325
  EXPECT_EQ(mozc::commands::HALF_ASCII, command.output().mode());
 
3326
  EXPECT_TRUE(command.output().has_candidates());
 
3327
  EXPECT_TRUE(command.output().has_preedit());
 
3328
}
 
3329
 
 
3330
 
2898
3331
// since History segments are almost hidden from
2899
3332
namespace {
2900
3333
class ConverterMockForReset : public ConverterMock {
2941
3374
// Independent test
2942
3375
TEST(SessionResetTest, IssueResetConversion) {
2943
3376
  scoped_ptr<ConverterMockForReset> convertermock(new ConverterMockForReset);
2944
 
  ConverterInterface::SetConverter(convertermock.get());
 
3377
  ConverterFactory::SetConverter(convertermock.get());
2945
3378
  scoped_ptr<SessionHandler> handler(new SessionHandler);
2946
3379
  scoped_ptr<Session> session(handler->NewSession());
 
3380
  InitSessionToPrecomposition(session.get());
2947
3381
  commands::Command command;
2948
3382
 
2949
3383
  // any meaneangless key calles ResetConversion
2959
3393
 
2960
3394
TEST(SessionRevertTest, IssueRevert) {
2961
3395
  scoped_ptr<ConverterMockForRevert> convertermock(new ConverterMockForRevert);
2962
 
  ConverterInterface::SetConverter(convertermock.get());
 
3396
  ConverterFactory::SetConverter(convertermock.get());
2963
3397
  scoped_ptr<SessionHandler> handler(new SessionHandler);
2964
3398
  scoped_ptr<Session> session(handler->NewSession());
 
3399
  InitSessionToPrecomposition(session.get());
2965
3400
  commands::Command command;
2966
3401
 
2967
3402
  // changes the state to PRECOMPOSITION