← Back to branch summary

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

« back to all changes in this revision

Viewing changes to client/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:
client/session_test.cc
55
55
}
56
56
}
57
57
 
58
 
class TestStartServerHandler : public StartServerHandlerInterface {
 
58
class TestServerLauncher : public ServerLauncherInterface {
59
59
 public:
60
 
  TestStartServerHandler(IPCClientFactoryMock *factory)
 
60
  TestServerLauncher(IPCClientFactoryMock *factory)
61
61
      : factory_(factory),
62
62
        start_server_result_(false),
63
63
        start_server_called_(false),
90
90
    return true;
91
91
  }
92
92
 
93
 
  virtual void OnFatal(StartServerHandlerInterface::ServerErrorType type) {
 
93
  virtual void OnFatal(ServerLauncherInterface::ServerErrorType type) {
94
94
    LOG(ERROR) << static_cast<int>(type);
95
95
    error_map_[static_cast<int>(type)]++;
96
96
  }
97
97
 
98
 
  int error_count(StartServerHandlerInterface::ServerErrorType type) {
 
98
  int error_count(ServerLauncherInterface::ServerErrorType type) {
99
99
    return error_map_[static_cast<int>(type)];
100
100
  }
101
101
 
115
115
    force_terminate_server_called_ = force_terminate_server_called;
116
116
  }
117
117
 
 
118
  void set_server_program(const string &server_path) {
 
119
  }
 
120
 
118
121
  virtual const string &server_program() const {
119
122
    static const string path;
120
123
    return path;
167
170
    session_.reset(new Session);
168
171
    session_->SetIPCClientFactory(client_factory_.get());
169
172
 
170
 
    start_server_handler_ = new TestStartServerHandler(client_factory_.get());
171
 
    session_->SetStartServerHandler(start_server_handler_);
 
173
    server_launcher_ = new TestServerLauncher(client_factory_.get());
 
174
    session_->SetServerLauncher(server_launcher_);
172
175
  }
173
176
 
174
177
  virtual void TearDown() {
198
201
    } else {
199
202
      client_factory_->SetServerProductVersion(UpdateVersion(version_diff_));
200
203
    }
201
 
    start_server_handler_->set_start_server_result(true);
 
204
    server_launcher_->set_start_server_result(true);
202
205
 
203
206
    // TODO(komatsu): Due to the limitation of the testing mock,
204
207
    // EnsureConnection should be explicitly called before calling
211
214
 
212
215
  scoped_ptr<IPCClientFactoryMock> client_factory_;
213
216
  scoped_ptr<Session> session_;
214
 
  TestStartServerHandler *start_server_handler_;
 
217
  TestServerLauncher *server_launcher_;
215
218
  int version_diff_;
216
219
 
217
220
 private:
220
223
 
221
224
TEST_F(SessionTest, ConnectionError) {
222
225
  client_factory_->SetConnection(false);
223
 
  start_server_handler_->set_start_server_result(false);
 
226
  server_launcher_->set_start_server_result(false);
224
227
  EXPECT_FALSE(session_->EnsureConnection());
225
228
 
226
229
  commands::KeyEvent key;
378
381
  commands::Output output;
379
382
  EXPECT_FALSE(session_->SendKey(key_event, &output));
380
383
  EXPECT_FALSE(session_->EnsureConnection());
381
 
  EXPECT_EQ(1, start_server_handler_->error_count
382
 
            (StartServerHandlerInterface::SERVER_VERSION_MISMATCH));
 
384
  EXPECT_EQ(1, server_launcher_->error_count
 
385
            (ServerLauncherInterface::SERVER_VERSION_MISMATCH));
383
386
}
384
387
 
385
388
TEST_F(SessionTest, ProtocolUpdate) {
386
 
  start_server_handler_->set_start_server_result(true);
 
389
  server_launcher_->set_start_server_result(true);
387
390
 
388
391
  const int mock_id = 0;
389
392
  EXPECT_TRUE(SetupConnection(mock_id));
393
396
  SetMockOutput(mock_output);
394
397
  EXPECT_TRUE(session_->EnsureConnection());
395
398
 
396
 
  start_server_handler_->set_force_terminate_server_called(false);
397
 
  start_server_handler_->set_force_terminate_server_result(true);
398
 
  start_server_handler_->set_start_server_called(false);
 
399
  server_launcher_->set_force_terminate_server_called(false);
 
400
  server_launcher_->set_force_terminate_server_result(true);
 
401
  server_launcher_->set_start_server_called(false);
399
402
 
400
403
  // Now connecting to an old server
401
404
  client_factory_->SetServerProtocolVersion(IPC_PROTOCOL_VERSION - 1);
402
405
  // after start server, protocol version becomes the same
403
 
  start_server_handler_->set_server_protocol_version(IPC_PROTOCOL_VERSION);
 
406
  server_launcher_->set_server_protocol_version(IPC_PROTOCOL_VERSION);
404
407
 
405
408
  EXPECT_TRUE(session_->EnsureSession());
406
 
  EXPECT_TRUE(start_server_handler_->start_server_called());
407
 
  EXPECT_TRUE(start_server_handler_->force_terminate_server_called());
 
409
  EXPECT_TRUE(server_launcher_->start_server_called());
 
410
  EXPECT_TRUE(server_launcher_->force_terminate_server_called());
408
411
}
409
412
 
410
413
TEST_F(SessionTest, ProtocolUpdateFailSameBinary) {
411
 
  start_server_handler_->set_start_server_result(true);
 
414
  server_launcher_->set_start_server_result(true);
412
415
 
413
416
  const int mock_id = 0;
414
417
  EXPECT_TRUE(SetupConnection(mock_id));
418
421
  SetMockOutput(mock_output);
419
422
  EXPECT_TRUE(session_->EnsureConnection());
420
423
 
421
 
  start_server_handler_->set_force_terminate_server_called(false);
422
 
  start_server_handler_->set_force_terminate_server_result(true);
423
 
  start_server_handler_->set_start_server_called(false);
 
424
  server_launcher_->set_force_terminate_server_called(false);
 
425
  server_launcher_->set_force_terminate_server_result(true);
 
426
  server_launcher_->set_start_server_called(false);
424
427
 
425
 
  EXPECT_FALSE(start_server_handler_->start_server_called());
 
428
  EXPECT_FALSE(server_launcher_->start_server_called());
426
429
 
427
430
  // version is updated after restart the server
428
431
  client_factory_->SetServerProtocolVersion(IPC_PROTOCOL_VERSION - 1);
429
432
  // even after server reboot, protocol version is old
430
 
  start_server_handler_->set_server_protocol_version(IPC_PROTOCOL_VERSION - 1);
431
 
  start_server_handler_->set_mock_after_start_server(mock_output);
 
433
  server_launcher_->set_server_protocol_version(IPC_PROTOCOL_VERSION - 1);
 
434
  server_launcher_->set_mock_after_start_server(mock_output);
432
435
  EXPECT_FALSE(session_->EnsureSession());
433
 
  EXPECT_TRUE(start_server_handler_->start_server_called());
434
 
  EXPECT_TRUE(start_server_handler_->force_terminate_server_called());
 
436
  EXPECT_TRUE(server_launcher_->start_server_called());
 
437
  EXPECT_TRUE(server_launcher_->force_terminate_server_called());
435
438
  EXPECT_FALSE(session_->EnsureConnection());
436
 
  EXPECT_EQ(1, start_server_handler_->error_count
437
 
            (StartServerHandlerInterface::SERVER_BROKEN_MESSAGE));
 
439
  EXPECT_EQ(1, server_launcher_->error_count
 
440
            (ServerLauncherInterface::SERVER_BROKEN_MESSAGE));
438
441
}
439
442
 
440
443
TEST_F(SessionTest, ProtocolUpdateFailOnTerminate) {
441
 
  start_server_handler_->set_start_server_result(true);
 
444
  server_launcher_->set_start_server_result(true);
442
445
 
443
446
  const int mock_id = 0;
444
447
  EXPECT_TRUE(SetupConnection(mock_id));
448
451
  SetMockOutput(mock_output);
449
452
  EXPECT_TRUE(session_->EnsureConnection());
450
453
 
451
 
  start_server_handler_->set_force_terminate_server_called(false);
452
 
  start_server_handler_->set_force_terminate_server_result(false);
453
 
  start_server_handler_->set_start_server_called(false);
 
454
  server_launcher_->set_force_terminate_server_called(false);
 
455
  server_launcher_->set_force_terminate_server_result(false);
 
456
  server_launcher_->set_start_server_called(false);
454
457
 
455
 
  EXPECT_FALSE(start_server_handler_->start_server_called());
 
458
  EXPECT_FALSE(server_launcher_->start_server_called());
456
459
 
457
460
  // version is updated after restart the server
458
461
  client_factory_->SetServerProtocolVersion(IPC_PROTOCOL_VERSION - 1);
459
462
  // even after server reboot, protocol version is old
460
 
  start_server_handler_->set_server_protocol_version(IPC_PROTOCOL_VERSION);
461
 
  start_server_handler_->set_mock_after_start_server(mock_output);
 
463
  server_launcher_->set_server_protocol_version(IPC_PROTOCOL_VERSION);
 
464
  server_launcher_->set_mock_after_start_server(mock_output);
462
465
  EXPECT_FALSE(session_->EnsureSession());
463
 
  EXPECT_FALSE(start_server_handler_->start_server_called());
464
 
  EXPECT_TRUE(start_server_handler_->force_terminate_server_called());
 
466
  EXPECT_FALSE(server_launcher_->start_server_called());
 
467
  EXPECT_TRUE(server_launcher_->force_terminate_server_called());
465
468
  EXPECT_FALSE(session_->EnsureConnection());
466
 
  EXPECT_EQ(1, start_server_handler_->error_count
467
 
            (StartServerHandlerInterface::SERVER_BROKEN_MESSAGE));
 
469
  EXPECT_EQ(1, server_launcher_->error_count
 
470
            (ServerLauncherInterface::SERVER_BROKEN_MESSAGE));
468
471
}
469
472
 
470
473
TEST_F(SessionTest, ServerUpdate) {
471
474
  SetupProductVersion(-1);  // old version
472
 
  start_server_handler_->set_start_server_result(true);
 
475
  server_launcher_->set_start_server_result(true);
473
476
 
474
477
  const int mock_id = 0;
475
478
  EXPECT_TRUE(SetupConnection(mock_id));
481
484
  SetMockOutput(mock_output);
482
485
  EXPECT_TRUE(session_->EnsureConnection());
483
486
 
484
 
  start_server_handler_->set_start_server_called(false);
485
 
  EXPECT_FALSE(start_server_handler_->start_server_called());
 
487
  server_launcher_->set_start_server_called(false);
 
488
  EXPECT_FALSE(server_launcher_->start_server_called());
486
489
 
487
490
  // version is updated after restart the server
488
 
  start_server_handler_->set_product_version_after_start_server(
 
491
  server_launcher_->set_product_version_after_start_server(
489
492
      Version::GetMozcVersion());
490
493
  EXPECT_TRUE(session_->EnsureSession());
491
 
  EXPECT_TRUE(start_server_handler_->start_server_called());
 
494
  EXPECT_TRUE(server_launcher_->start_server_called());
492
495
}
493
496
 
494
497
TEST_F(SessionTest, ServerUpdateToNewer) {
495
498
  SetupProductVersion(1);  // new version
496
 
  start_server_handler_->set_start_server_result(true);
 
499
  server_launcher_->set_start_server_result(true);
497
500
 
498
501
  const int mock_id = 0;
499
502
  EXPECT_TRUE(SetupConnection(mock_id));
504
507
  mock_output.set_id(mock_id);
505
508
  SetMockOutput(mock_output);
506
509
  EXPECT_TRUE(session_->EnsureConnection());
507
 
  start_server_handler_->set_start_server_called(false);
 
510
  server_launcher_->set_start_server_called(false);
508
511
  EXPECT_TRUE(session_->EnsureSession());
509
 
  EXPECT_FALSE(start_server_handler_->start_server_called());
 
512
  EXPECT_FALSE(server_launcher_->start_server_called());
510
513
}
511
514
 
512
515
TEST_F(SessionTest, ServerUpdateFail) {
513
516
  SetupProductVersion(-1);  // old
514
 
  start_server_handler_->set_start_server_result(true);
 
517
  server_launcher_->set_start_server_result(true);
515
518
 
516
519
  const int mock_id = 0;
517
520
  EXPECT_TRUE(SetupConnection(mock_id));
521
524
  SetMockOutput(mock_output);
522
525
  EXPECT_TRUE(session_->EnsureConnection());
523
526
 
524
 
  start_server_handler_->set_start_server_called(false);
525
 
  EXPECT_FALSE(start_server_handler_->start_server_called());
 
527
  server_launcher_->set_start_server_called(false);
 
528
  EXPECT_FALSE(server_launcher_->start_server_called());
526
529
 
527
530
  // version is not updated after restart the server
528
 
  start_server_handler_->set_mock_after_start_server(mock_output);
 
531
  server_launcher_->set_mock_after_start_server(mock_output);
529
532
  EXPECT_FALSE(session_->EnsureSession());
530
 
  EXPECT_TRUE(start_server_handler_->start_server_called());
 
533
  EXPECT_TRUE(server_launcher_->start_server_called());
531
534
  EXPECT_FALSE(session_->EnsureConnection());
532
 
  EXPECT_EQ(1, start_server_handler_->error_count
533
 
            (StartServerHandlerInterface::SERVER_BROKEN_MESSAGE));
 
535
  EXPECT_EQ(1, server_launcher_->error_count
 
536
            (ServerLauncherInterface::SERVER_BROKEN_MESSAGE));
 
537
}
 
538
 
 
539
class SessionPlaybackTestServerLauncher :
 
540
      public ServerLauncherInterface {
 
541
 public:
 
542
  SessionPlaybackTestServerLauncher(IPCClientFactoryMock *factory)
 
543
      : factory_(factory),
 
544
        start_server_result_(false),
 
545
        start_server_called_(false),
 
546
        force_terminate_server_result_(false),
 
547
        force_terminate_server_called_(false),
 
548
        server_protocol_version_(IPC_PROTOCOL_VERSION) {}
 
549
 
 
550
  virtual void Ready() {}
 
551
  virtual void Wait() {}
 
552
  virtual void Error() {}
 
553
 
 
554
  virtual bool StartServer(SessionInterface *session) {
 
555
    if (!response_.empty()) {
 
556
      factory_->SetMockResponse(response_);
 
557
    }
 
558
    if (!product_version_after_start_server_.empty()) {
 
559
      factory_->SetServerProductVersion(product_version_after_start_server_);
 
560
    }
 
561
    factory_->SetServerProtocolVersion(server_protocol_version_);
 
562
    start_server_called_ = true;
 
563
    return start_server_result_;
 
564
  }
 
565
 
 
566
  virtual bool ForceTerminateServer(const string &name) {
 
567
    force_terminate_server_called_ = true;
 
568
    return force_terminate_server_result_;
 
569
  }
 
570
 
 
571
  virtual bool WaitServer(uint32 pid) {
 
572
    return true;
 
573
  }
 
574
 
 
575
  virtual void OnFatal(ServerLauncherInterface::ServerErrorType type) {
 
576
  }
 
577
 
 
578
  void set_server_program(const string &server_path) {}
 
579
 
 
580
  void set_restricted(bool restricted) {}
 
581
 
 
582
  void set_start_server_result(const bool result) {
 
583
    start_server_result_ = result;
 
584
  }
 
585
 
 
586
 
 
587
  virtual const string &server_program() const {
 
588
    static const string path;
 
589
    return path;
 
590
  }
 
591
 
 
592
 private:
 
593
  IPCClientFactoryMock *factory_;
 
594
  bool start_server_result_;
 
595
  bool start_server_called_;
 
596
  bool force_terminate_server_result_;
 
597
  bool force_terminate_server_called_;
 
598
  uint32 server_protocol_version_;
 
599
  string response_;
 
600
  string product_version_after_start_server_;
 
601
  map<int, int> error_map_;
 
602
};
 
603
 
 
604
class SessionPlaybackTest : public testing::Test {
 
605
 protected:
 
606
  SessionPlaybackTest() {}
 
607
 
 
608
  virtual void SetUp() {
 
609
    client_factory_.reset(new IPCClientFactoryMock);
 
610
    client_.reset(reinterpret_cast<IPCClientMock *>(
 
611
        client_factory_->NewClient("")));
 
612
    session_.reset(new Session);
 
613
    session_->SetIPCClientFactory(client_factory_.get());
 
614
    server_launcher_ = new SessionPlaybackTestServerLauncher(
 
615
        client_factory_.get());
 
616
    session_->SetServerLauncher(server_launcher_);
 
617
  }
 
618
 
 
619
  virtual void TearDown() {
 
620
    session_.reset();
 
621
    client_factory_.reset();
 
622
  }
 
623
 
 
624
  bool SetupConnection(const int id) {
 
625
    client_factory_->SetConnection(true);
 
626
    client_factory_->SetResult(true);
 
627
    client_factory_->SetServerProductVersion(Version::GetMozcVersion());
 
628
    server_launcher_->set_start_server_result(true);
 
629
 
 
630
    // TODO(komatsu): Due to the limitation of the testing mock,
 
631
    // EnsureConnection should be explicitly called before calling
 
632
    // SendKey.  Fix the testing mock.
 
633
    commands::Output mock_output;
 
634
    mock_output.set_id(id);
 
635
    SetMockOutput(mock_output);
 
636
    return session_->EnsureConnection();
 
637
  }
 
638
 
 
639
  void SetMockOutput(const commands::Output &mock_output) {
 
640
    string response;
 
641
    mock_output.SerializeToString(&response);
 
642
    client_factory_->SetMockResponse(response);
 
643
  }
 
644
 
 
645
  void GetGeneratedInput(commands::Input *input) {
 
646
    input->ParseFromString(client_factory_->GetGeneratedRequest());
 
647
  }
 
648
 
 
649
  scoped_ptr<IPCClientFactoryMock> client_factory_;
 
650
  scoped_ptr<IPCClientMock> client_;
 
651
  scoped_ptr<Session> session_;
 
652
  SessionPlaybackTestServerLauncher *server_launcher_;
 
653
 
 
654
 private:
 
655
  DISALLOW_COPY_AND_ASSIGN(SessionPlaybackTest);
 
656
};
 
657
 
 
658
// TODO(toshiyuki): Update these test after the implementation for Mac.
 
659
 
 
660
TEST_F(SessionPlaybackTest, PushAndResetHistoryWithNoModeTest) {
 
661
  const int mock_id = 123;
 
662
  EXPECT_TRUE(SetupConnection(mock_id));
 
663
 
 
664
  commands::KeyEvent key_event;
 
665
  key_event.set_special_key(commands::KeyEvent::ENTER);
 
666
 
 
667
  commands::Output mock_output;
 
668
  mock_output.set_id(mock_id);
 
669
  mock_output.set_consumed(true);
 
670
  SetMockOutput(mock_output);
 
671
 
 
672
  commands::Output output;
 
673
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
674
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
675
 
 
676
  vector<commands::Input> history;
 
677
  session_->GetHistoryInputs(&history);
 
678
  EXPECT_EQ(1, history.size());
 
679
 
 
680
  mock_output.Clear();
 
681
  mock_output.set_id(mock_id);
 
682
  mock_output.set_consumed(true);
 
683
  mock_output.mutable_result()->set_type(commands::Result::STRING);
 
684
  mock_output.mutable_result()->set_value("output");
 
685
  EXPECT_FALSE(mock_output.has_mode());
 
686
  SetMockOutput(mock_output);
 
687
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
688
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
689
 
 
690
  // history should be reset.
 
691
  session_->GetHistoryInputs(&history);
 
692
  EXPECT_EQ(0, history.size());
 
693
}
 
694
 
 
695
TEST_F(SessionPlaybackTest, PushAndResetHistoryWithModeTest) {
 
696
#ifdef OS_WINDOWS
 
697
  const int mock_id = 123;
 
698
  EXPECT_TRUE(SetupConnection(mock_id));
 
699
 
 
700
  commands::KeyEvent key_event;
 
701
  key_event.set_special_key(commands::KeyEvent::ENTER);
 
702
 
 
703
  // On Windows, mode initializer should be added if the output contains mode.
 
704
  commands::Output mock_output;
 
705
  mock_output.set_id(mock_id);
 
706
  mock_output.set_consumed(true);
 
707
  mock_output.set_mode(commands::HIRAGANA);
 
708
  SetMockOutput(mock_output);
 
709
 
 
710
  commands::Output output;
 
711
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
712
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
713
  EXPECT_TRUE(output.has_mode());
 
714
  EXPECT_EQ(commands::HIRAGANA, output.mode());
 
715
 
 
716
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
717
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
718
  EXPECT_TRUE(output.has_mode());
 
719
  EXPECT_EQ(commands::HIRAGANA, output.mode());
 
720
 
 
721
  vector<commands::Input> history;
 
722
  session_->GetHistoryInputs(&history);
 
723
  EXPECT_EQ(2, history.size());
 
724
 
 
725
  mock_output.Clear();
 
726
  mock_output.set_id(mock_id);
 
727
  mock_output.set_consumed(true);
 
728
  mock_output.mutable_result()->set_type(commands::Result::STRING);
 
729
  mock_output.mutable_result()->set_value("output");
 
730
  SetMockOutput(mock_output);
 
731
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
732
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
733
  // history is reset, but initializer should be added.
 
734
  session_->GetHistoryInputs(&history);
 
735
  EXPECT_EQ(1, history.size());
 
736
#endif
 
737
}
 
738
 
 
739
TEST_F(SessionPlaybackTest, PushAndResetHistoryWithDirectTest) {
 
740
#ifdef OS_WINDOWS
 
741
  const int mock_id = 123;
 
742
  EXPECT_TRUE(SetupConnection(mock_id));
 
743
 
 
744
  commands::KeyEvent key_event;
 
745
  key_event.set_special_key(commands::KeyEvent::ENTER);
 
746
 
 
747
  // On Windows, mode initializer should be added if the output contains mode.
 
748
  commands::Output mock_output;
 
749
  mock_output.set_id(mock_id);
 
750
  mock_output.set_consumed(true);
 
751
  mock_output.set_mode(commands::DIRECT);
 
752
  SetMockOutput(mock_output);
 
753
 
 
754
  commands::Output output;
 
755
  // Send key twice
 
756
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
757
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
758
  EXPECT_TRUE(output.has_mode());
 
759
  EXPECT_EQ(commands::DIRECT, output.mode());
 
760
 
 
761
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
762
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
763
  EXPECT_TRUE(output.has_mode());
 
764
  EXPECT_EQ(commands::DIRECT, output.mode());
 
765
 
 
766
  vector<commands::Input> history;
 
767
  session_->GetHistoryInputs(&history);
 
768
  EXPECT_EQ(2, history.size());
 
769
 
 
770
  mock_output.Clear();
 
771
  mock_output.set_id(mock_id);
 
772
  mock_output.set_consumed(true);
 
773
  mock_output.mutable_result()->set_type(commands::Result::STRING);
 
774
  mock_output.mutable_result()->set_value("output");
 
775
  SetMockOutput(mock_output);
 
776
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
777
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
778
  // history is reset, and initializer should not be added.
 
779
  session_->GetHistoryInputs(&history);
 
780
  EXPECT_EQ(0, history.size());
 
781
#endif
 
782
}
 
783
 
 
784
TEST_F(SessionPlaybackTest, PlaybackHistoryTest) {
 
785
  const int mock_id = 123;
 
786
  EXPECT_TRUE(SetupConnection(mock_id));
 
787
 
 
788
  commands::KeyEvent key_event;
 
789
  key_event.set_special_key(commands::KeyEvent::ENTER);
 
790
 
 
791
  // On Windows, mode initializer should be added if the output contains mode.
 
792
  commands::Output mock_output;
 
793
  mock_output.set_id(mock_id);
 
794
  mock_output.set_consumed(true);
 
795
  SetMockOutput(mock_output);
 
796
 
 
797
  commands::Output output;
 
798
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
799
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
800
 
 
801
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
802
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
803
 
 
804
  vector<commands::Input> history;
 
805
  session_->GetHistoryInputs(&history);
 
806
  EXPECT_EQ(2, history.size());
 
807
 
 
808
  // Invalid id
 
809
  const int new_id = 456;
 
810
  mock_output.set_id(new_id);
 
811
  SetMockOutput(mock_output);
 
812
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
813
 
 
814
#ifndef _DEBUG
 
815
  // PlaybackHistory and push history
 
816
  session_->GetHistoryInputs(&history);
 
817
  EXPECT_EQ(3, history.size());
 
818
#else
 
819
  // PlaybackHistory, dump history(including reset), and add last input
 
820
  session_->GetHistoryInputs(&history);
 
821
  EXPECT_EQ(1, history.size());
 
822
#endif
 
823
}
 
824
 
 
825
TEST_F(SessionPlaybackTest, SetModeInitializerTest) {
 
826
#ifdef OS_WINDOWS
 
827
  const int mock_id = 123;
 
828
  EXPECT_TRUE(SetupConnection(mock_id));
 
829
 
 
830
  commands::KeyEvent key_event;
 
831
  key_event.set_special_key(commands::KeyEvent::ENTER);
 
832
 
 
833
  // On Windows, mode initializer should be added if the output contains mode.
 
834
  commands::Output mock_output;
 
835
  mock_output.set_id(mock_id);
 
836
  mock_output.set_consumed(true);
 
837
  mock_output.set_mode(commands::HIRAGANA);
 
838
  SetMockOutput(mock_output);
 
839
 
 
840
  commands::Output output;
 
841
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
842
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
843
 
 
844
  mock_output.set_mode(commands::DIRECT);
 
845
  SetMockOutput(mock_output);
 
846
 
 
847
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
848
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
849
  EXPECT_TRUE(output.has_mode());
 
850
  EXPECT_EQ(commands::DIRECT, output.mode());
 
851
 
 
852
  mock_output.set_mode(commands::FULL_KATAKANA);
 
853
  SetMockOutput(mock_output);
 
854
 
 
855
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
856
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
857
  EXPECT_TRUE(output.has_mode());
 
858
  EXPECT_EQ(commands::FULL_KATAKANA, output.mode());
 
859
 
 
860
  vector<commands::Input> history;
 
861
  session_->GetHistoryInputs(&history);
 
862
  EXPECT_EQ(3, history.size());
 
863
 
 
864
  mock_output.Clear();
 
865
  mock_output.set_id(mock_id);
 
866
  mock_output.set_consumed(true);
 
867
  mock_output.mutable_result()->set_type(commands::Result::STRING);
 
868
  mock_output.mutable_result()->set_value("output");
 
869
  SetMockOutput(mock_output);
 
870
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
871
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
872
  // history is reset, but initializer should be added.
 
873
  session_->GetHistoryInputs(&history);
 
874
  EXPECT_EQ(1, history.size());
 
875
  EXPECT_EQ(commands::FULL_KATAKANA, history[0].key().mode());
 
876
#endif
 
877
}
 
878
 
 
879
TEST_F(SessionPlaybackTest, ConsumedTest) {
 
880
  const int mock_id = 123;
 
881
  EXPECT_TRUE(SetupConnection(mock_id));
 
882
 
 
883
  commands::KeyEvent key_event;
 
884
  key_event.set_special_key(commands::KeyEvent::ENTER);
 
885
 
 
886
  commands::Output mock_output;
 
887
  mock_output.set_id(mock_id);
 
888
  mock_output.set_consumed(true);
 
889
  SetMockOutput(mock_output);
 
890
 
 
891
  commands::Output output;
 
892
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
893
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
894
 
 
895
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
896
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
897
 
 
898
  vector<commands::Input> history;
 
899
  session_->GetHistoryInputs(&history);
 
900
  EXPECT_EQ(2, history.size());
 
901
 
 
902
  mock_output.set_consumed(false);
 
903
  SetMockOutput(mock_output);
 
904
 
 
905
  EXPECT_TRUE(session_->SendKey(key_event, &output));
 
906
  EXPECT_EQ(mock_output.consumed(), output.consumed());
 
907
 
 
908
  // Do not push unconsumed input
 
909
  session_->GetHistoryInputs(&history);
 
910
  EXPECT_EQ(2, history.size());
534
911
}
535
912
}  // namespace client
536
913
}  // namespace mozc