src/unix/ibus/gtk_candidate_window_handler_test.cc - mozc - Git at Google

 // Copyright 2010-2015, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include "unix/ibus/gtk_candidate_window_handler.h"

 #include <unistd.h>  // for getpid()

 #include "renderer/renderer_command.pb.h"
 #include "renderer/renderer_mock.h"
 #include "testing/base/public/gmock.h"
 #include "testing/base/public/gunit.h"

 using ::testing::AllOf;
 using ::testing::Property;
 using ::testing::Return;
 using mozc::commands::Candidates;
 using mozc::commands::Command;
 using mozc::commands::Output;
 using mozc::commands::RendererCommand;
 using mozc::renderer::RendererInterface;
 using mozc::renderer::RendererMock;
 typedef mozc::commands::Candidates_Candidate Candidate;
 typedef mozc::commands::RendererCommand_ApplicationInfo ApplicationInfo;

 namespace mozc {
 namespace ibus {

 class TestableGtkCandidateWindowHandler : public GtkCandidateWindowHandler {
  public:
   explicit TestableGtkCandidateWindowHandler(RendererInterface *renderer)
       : GtkCandidateWindowHandler(renderer) {}
   virtual ~TestableGtkCandidateWindowHandler() {}

   // Change access rights.
   using GtkCandidateWindowHandler::SendUpdateCommand;
   using GtkCandidateWindowHandler::renderer_;
   using GtkCandidateWindowHandler::last_update_output_;
 };

 namespace {

 MATCHER(IsIBusMozcRendererRequest, "") {
   const ApplicationInfo &info = arg.application_info();
   if (!info.has_process_id()) {
     *result_listener << "ApplicationInfo::process_id does not exist";
     return false;
   }
   if (::getpid() != info.process_id()) {
     *result_listener << "ProcessId does not match\n"
                      << "  expected: " << ::getpid() << "\n"
                      << "  actual:   " << info.process_id();
     return false;
   }
   if (!info.has_input_framework()) {
     *result_listener << "ApplicationInfo::input_framework does not exist";
     return false;
   }
   if (ApplicationInfo::IBus != info.input_framework()) {
     *result_listener << "InputFramework does not match\n"
                      << "  expected: " << ApplicationInfo::IBus << "\n"
                      << "  actual:   " << info.input_framework();
     return false;
   }
   return true;
 }

 MATCHER_P(VisibilityEq, visibility, "") {
   if (!arg.has_visible()) {
     *result_listener << "RendererCommand::visible does not exist";
     return false;
   }
   if (RendererCommand::UPDATE != arg.type()) {
     *result_listener << "RendererCommand::type does not match\n"
                      << "  expected: " << RendererCommand::UPDATE << "\n"
                      << "  actual:   " << arg.type();
     return false;
   }
   if (visibility != arg.visible()) {
     *result_listener << "The visibility does not match\n"
                      << "  expected: " << visibility << "\n"
                      << "  actual:   " << arg.visible();
     return false;
   }
   return true;
 }

 MATCHER_P(OutputEq, expected, "") {
   if (expected.Utf8DebugString() != arg.Utf8DebugString()) {
     *result_listener
         << "The output does not match\n"
         << "  expected: \n" << expected.Utf8DebugString() << "\n"
         << "  actual:   \n" << arg.Utf8DebugString();
     return false;
   }

   return true;
 }

 #define EXPECT_CALL_EXEC_COMMAND(mock, ...)                              \
     EXPECT_CALL((mock), ExecCommand(                                     \
         AllOf(IsIBusMozcRendererRequest(), __VA_ARGS__)))

 }  // namespace

 TEST(GtkCandidateWindowHandlerTest, SendUpdateCommandTest) {
   {
     SCOPED_TRACE("visibility check. false case");
     Output output;
     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(false));
     gtk_candidate_window_handler.SendUpdateCommand(output, false);
   }
   {
     SCOPED_TRACE("visibility check. true case");
     Output output;
     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true));
     gtk_candidate_window_handler.SendUpdateCommand(output, true);
   }
   {
     SCOPED_TRACE("return value check. false case.");
     Output output;
     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true))
         .WillOnce(Return(false));
     EXPECT_FALSE(gtk_candidate_window_handler.SendUpdateCommand(output, true));
   }
   {
     SCOPED_TRACE("return value check. true case.");
     Output output;
     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true))
         .WillOnce(Return(true));
     EXPECT_TRUE(gtk_candidate_window_handler.SendUpdateCommand(output, true));
   }
 }

 TEST(GtkCandidateWindowHandlerTest, UpdateTest) {
   const int sample_idx1 = 0;
   const int sample_idx2 = 1;
   const char *sample_candidate1 = "SAMPLE_CANDIDATE1";
   const char *sample_candidate2 = "SAMPLE_CANDIDATE2";
   {
     SCOPED_TRACE("If there are no candidates, visibility expects false");
     Output output;
     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(false));
     gtk_candidate_window_handler.Update(NULL, output);
   }
   {
     SCOPED_TRACE("If there is at least one candidate, "
                  "visibility expects true");
     Output output;
     Candidates *candidates = output.mutable_candidates();
     Candidate *candidate = candidates->add_candidate();
     candidate->set_index(sample_idx1);
     candidate->set_value(sample_candidate1);
     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true));
     gtk_candidate_window_handler.Update(NULL, output);
   }
   {
     SCOPED_TRACE("Update last updated output protobuf object.");
     Output output1;
     Output output2;
     Candidates *candidates1 = output1.mutable_candidates();
     Candidates *candidates2 = output2.mutable_candidates();
     Candidate *candidate1 = candidates1->add_candidate();
     Candidate *candidate2 = candidates2->add_candidate();
     candidate1->set_index(sample_idx1);
     candidate1->set_index(sample_idx2);
     candidate2->set_value(sample_candidate1);
     candidate2->set_value(sample_candidate2);

     RendererMock *renderer_mock = new RendererMock();
     TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
         renderer_mock);
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock,
                              Property(&RendererCommand::output,
                                       OutputEq(output1)))
         .WillOnce(Return(true));
     EXPECT_CALL_EXEC_COMMAND(*renderer_mock,
                              Property(&RendererCommand::output,
                                       OutputEq(output2)))
         .WillOnce(Return(true));
     gtk_candidate_window_handler.Update(NULL, output1);
     EXPECT_THAT(*(gtk_candidate_window_handler.last_update_output_.get()),
                 OutputEq(output1));
     gtk_candidate_window_handler.Update(NULL, output2);
     EXPECT_THAT(*(gtk_candidate_window_handler.last_update_output_.get()),
                 OutputEq(output2));
   }
 }

 TEST(GtkCandidateWindowHandlerTest, HideTest) {
   RendererMock *renderer_mock = new RendererMock();
   TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
       renderer_mock);
   EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(false));
   gtk_candidate_window_handler.Hide(NULL);
 }

 TEST(GtkCandidateWindowHandlerTest, ShowTest) {
   RendererMock *renderer_mock = new RendererMock();
   TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
       renderer_mock);
   EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true));
   gtk_candidate_window_handler.Show(NULL);
 }

 }  // namespace ibus
 }  // namespace mozc
	// Copyright 2010-2015, Google Inc.
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#include "unix/ibus/gtk_candidate_window_handler.h"

	#include <unistd.h> // for getpid()

	#include "renderer/renderer_command.pb.h"
	#include "renderer/renderer_mock.h"
	#include "testing/base/public/gmock.h"
	#include "testing/base/public/gunit.h"

	using ::testing::AllOf;
	using ::testing::Property;
	using ::testing::Return;
	using mozc::commands::Candidates;
	using mozc::commands::Command;
	using mozc::commands::Output;
	using mozc::commands::RendererCommand;
	using mozc::renderer::RendererInterface;
	using mozc::renderer::RendererMock;
	typedef mozc::commands::Candidates_Candidate Candidate;
	typedef mozc::commands::RendererCommand_ApplicationInfo ApplicationInfo;

	namespace mozc {
	namespace ibus {

	class TestableGtkCandidateWindowHandler : public GtkCandidateWindowHandler {
	public:
	explicit TestableGtkCandidateWindowHandler(RendererInterface *renderer)
	: GtkCandidateWindowHandler(renderer) {}
	virtual ~TestableGtkCandidateWindowHandler() {}

	// Change access rights.
	using GtkCandidateWindowHandler::SendUpdateCommand;
	using GtkCandidateWindowHandler::renderer_;
	using GtkCandidateWindowHandler::last_update_output_;
	};

	namespace {

	MATCHER(IsIBusMozcRendererRequest, "") {
	const ApplicationInfo &info = arg.application_info();
	if (!info.has_process_id()) {
	*result_listener << "ApplicationInfo::process_id does not exist";
	return false;
	}
	if (::getpid() != info.process_id()) {
	*result_listener << "ProcessId does not match\n"
	<< " expected: " << ::getpid() << "\n"
	<< " actual: " << info.process_id();
	return false;
	}
	if (!info.has_input_framework()) {
	*result_listener << "ApplicationInfo::input_framework does not exist";
	return false;
	}
	if (ApplicationInfo::IBus != info.input_framework()) {
	*result_listener << "InputFramework does not match\n"
	<< " expected: " << ApplicationInfo::IBus << "\n"
	<< " actual: " << info.input_framework();
	return false;
	}
	return true;
	}

	MATCHER_P(VisibilityEq, visibility, "") {
	if (!arg.has_visible()) {
	*result_listener << "RendererCommand::visible does not exist";
	return false;
	}
	if (RendererCommand::UPDATE != arg.type()) {
	*result_listener << "RendererCommand::type does not match\n"
	<< " expected: " << RendererCommand::UPDATE << "\n"
	<< " actual: " << arg.type();
	return false;
	}
	if (visibility != arg.visible()) {
	*result_listener << "The visibility does not match\n"
	<< " expected: " << visibility << "\n"
	<< " actual: " << arg.visible();
	return false;
	}
	return true;
	}

	MATCHER_P(OutputEq, expected, "") {
	if (expected.Utf8DebugString() != arg.Utf8DebugString()) {
	*result_listener
	<< "The output does not match\n"
	<< " expected: \n" << expected.Utf8DebugString() << "\n"
	<< " actual: \n" << arg.Utf8DebugString();
	return false;
	}

	return true;
	}

	#define EXPECT_CALL_EXEC_COMMAND(mock, ...) \
	EXPECT_CALL((mock), ExecCommand( \
	AllOf(IsIBusMozcRendererRequest(), __VA_ARGS__)))

	} // namespace

	TEST(GtkCandidateWindowHandlerTest, SendUpdateCommandTest) {
	{
	SCOPED_TRACE("visibility check. false case");
	Output output;
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(false));
	gtk_candidate_window_handler.SendUpdateCommand(output, false);
	}
	{
	SCOPED_TRACE("visibility check. true case");
	Output output;
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true));
	gtk_candidate_window_handler.SendUpdateCommand(output, true);
	}
	{
	SCOPED_TRACE("return value check. false case.");
	Output output;
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true))
	.WillOnce(Return(false));
	EXPECT_FALSE(gtk_candidate_window_handler.SendUpdateCommand(output, true));
	}
	{
	SCOPED_TRACE("return value check. true case.");
	Output output;
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true))
	.WillOnce(Return(true));
	EXPECT_TRUE(gtk_candidate_window_handler.SendUpdateCommand(output, true));
	}
	}

	TEST(GtkCandidateWindowHandlerTest, UpdateTest) {
	const int sample_idx1 = 0;
	const int sample_idx2 = 1;
	const char *sample_candidate1 = "SAMPLE_CANDIDATE1";
	const char *sample_candidate2 = "SAMPLE_CANDIDATE2";
	{
	SCOPED_TRACE("If there are no candidates, visibility expects false");
	Output output;
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(false));
	gtk_candidate_window_handler.Update(NULL, output);
	}
	{
	SCOPED_TRACE("If there is at least one candidate, "
	"visibility expects true");
	Output output;
	Candidates *candidates = output.mutable_candidates();
	Candidate *candidate = candidates->add_candidate();
	candidate->set_index(sample_idx1);
	candidate->set_value(sample_candidate1);
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true));
	gtk_candidate_window_handler.Update(NULL, output);
	}
	{
	SCOPED_TRACE("Update last updated output protobuf object.");
	Output output1;
	Output output2;
	Candidates *candidates1 = output1.mutable_candidates();
	Candidates *candidates2 = output2.mutable_candidates();
	Candidate *candidate1 = candidates1->add_candidate();
	Candidate *candidate2 = candidates2->add_candidate();
	candidate1->set_index(sample_idx1);
	candidate1->set_index(sample_idx2);
	candidate2->set_value(sample_candidate1);
	candidate2->set_value(sample_candidate2);

	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock,
	Property(&RendererCommand::output,
	OutputEq(output1)))
	.WillOnce(Return(true));
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock,
	Property(&RendererCommand::output,
	OutputEq(output2)))
	.WillOnce(Return(true));
	gtk_candidate_window_handler.Update(NULL, output1);
	EXPECT_THAT(*(gtk_candidate_window_handler.last_update_output_.get()),
	OutputEq(output1));
	gtk_candidate_window_handler.Update(NULL, output2);
	EXPECT_THAT(*(gtk_candidate_window_handler.last_update_output_.get()),
	OutputEq(output2));
	}
	}

	TEST(GtkCandidateWindowHandlerTest, HideTest) {
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(false));
	gtk_candidate_window_handler.Hide(NULL);
	}

	TEST(GtkCandidateWindowHandlerTest, ShowTest) {
	RendererMock *renderer_mock = new RendererMock();
	TestableGtkCandidateWindowHandler gtk_candidate_window_handler(
	renderer_mock);
	EXPECT_CALL_EXEC_COMMAND(*renderer_mock, VisibilityEq(true));
	gtk_candidate_window_handler.Show(NULL);
	}

	} // namespace ibus
	} // namespace mozc