| // Copyright 2010-2014, 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 "session/session_handler_test_util.h" |
| |
| #include "base/config_file_stream.h" |
| #include "base/file_util.h" |
| #include "base/system_util.h" |
| #include "config/config.pb.h" |
| #include "config/config_handler.h" |
| #include "converter/converter_interface.h" |
| #include "engine/engine_interface.h" |
| #include "prediction/user_history_predictor.h" |
| #include "session/commands.pb.h" |
| #include "session/session_handler.h" |
| #include "session/session_handler_interface.h" |
| #include "session/session_usage_observer.h" |
| #include "storage/registry.h" |
| |
| DECLARE_string(test_tmpdir); |
| |
| DECLARE_int32(max_session_size); |
| DECLARE_int32(create_session_min_interval); |
| DECLARE_int32(watch_dog_interval); |
| DECLARE_int32(last_command_timeout); |
| DECLARE_int32(last_create_session_timeout); |
| DECLARE_bool(restricted); |
| |
| namespace mozc { |
| namespace session { |
| namespace testing { |
| |
| using commands::Command; |
| using config::ConfigHandler; |
| |
| bool CreateSession(SessionHandlerInterface *handler, uint64 *id) { |
| Command command; |
| command.mutable_input()->set_type(commands::Input::CREATE_SESSION); |
| command.mutable_input()->mutable_capability()->set_text_deletion( |
| commands::Capability::DELETE_PRECEDING_TEXT); |
| handler->EvalCommand(&command); |
| if (id != NULL) { |
| *id = command.has_output() ? command.output().id() : 0; |
| } |
| return (command.output().error_code() == commands::Output::SESSION_SUCCESS); |
| } |
| |
| bool DeleteSession(SessionHandlerInterface *handler, uint64 id) { |
| Command command; |
| command.mutable_input()->set_id(id); |
| command.mutable_input()->set_type(commands::Input::DELETE_SESSION); |
| return handler->EvalCommand(&command); |
| } |
| |
| bool CleanUp(SessionHandlerInterface *handler, uint64 id) { |
| Command command; |
| command.mutable_input()->set_id(id); |
| command.mutable_input()->set_type(commands::Input::CLEANUP); |
| return handler->EvalCommand(&command); |
| } |
| |
| bool ClearUserPrediction(SessionHandlerInterface *handler, uint64 id) { |
| Command command; |
| command.mutable_input()->set_id(id); |
| command.mutable_input()->set_type(commands::Input::CLEAR_USER_PREDICTION); |
| return handler->EvalCommand(&command); |
| } |
| |
| bool IsGoodSession(SessionHandlerInterface *handler, uint64 id) { |
| Command command; |
| command.mutable_input()->set_id(id); |
| command.mutable_input()->set_type(commands::Input::SEND_KEY); |
| command.mutable_input()->mutable_key()->set_special_key( |
| commands::KeyEvent::SPACE); |
| handler->EvalCommand(&command); |
| return (command.output().error_code() == commands::Output::SESSION_SUCCESS); |
| } |
| |
| SessionHandlerTestBase::SessionHandlerTestBase() { |
| } |
| SessionHandlerTestBase::~SessionHandlerTestBase() { |
| } |
| |
| void SessionHandlerTestBase::SetUp() { |
| flags_max_session_size_backup_ = FLAGS_max_session_size; |
| flags_create_session_min_interval_backup_ = FLAGS_create_session_min_interval; |
| flags_watch_dog_interval_backup_ = FLAGS_watch_dog_interval; |
| flags_last_command_timeout_backup_ = FLAGS_last_command_timeout; |
| flags_last_create_session_timeout_backup_ = FLAGS_last_create_session_timeout; |
| flags_restricted_backup_ = FLAGS_restricted; |
| |
| user_profile_directory_backup_ = SystemUtil::GetUserProfileDirectory(); |
| SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir); |
| ConfigHandler::GetConfig(&config_backup_); |
| ClearState(); |
| } |
| |
| void SessionHandlerTestBase::TearDown() { |
| ClearState(); |
| ConfigHandler::SetConfig(config_backup_); |
| SystemUtil::SetUserProfileDirectory(user_profile_directory_backup_); |
| |
| FLAGS_max_session_size = flags_max_session_size_backup_; |
| FLAGS_create_session_min_interval = flags_create_session_min_interval_backup_; |
| FLAGS_watch_dog_interval = flags_watch_dog_interval_backup_; |
| FLAGS_last_command_timeout = flags_last_command_timeout_backup_; |
| FLAGS_last_create_session_timeout = flags_last_create_session_timeout_backup_; |
| FLAGS_restricted = flags_restricted_backup_; |
| } |
| |
| void SessionHandlerTestBase::ClearState() { |
| config::Config config; |
| ConfigHandler::GetDefaultConfig(&config); |
| ConfigHandler::SetConfig(config); |
| |
| // Some destructors may save the state on storages. To clear the state, we |
| // explicitly call destructors before clearing storages. |
| storage::Registry::Clear(); |
| FileUtil::Unlink(ConfigFileStream::GetFileName("user://boundary.db")); |
| FileUtil::Unlink(ConfigFileStream::GetFileName("user://segment.db")); |
| FileUtil::Unlink(UserHistoryPredictor::GetUserHistoryFileName()); |
| } |
| |
| TestSessionClient::TestSessionClient(EngineInterface *engine) |
| : id_(0), |
| usage_observer_(new SessionUsageObserver), |
| handler_(new SessionHandler(engine)) { |
| handler_->AddObserver(usage_observer_.get()); |
| } |
| |
| TestSessionClient::~TestSessionClient() { |
| } |
| |
| bool TestSessionClient::CreateSession() { |
| return ::mozc::session::testing::CreateSession(handler_.get(), &id_); |
| } |
| |
| bool TestSessionClient::DeleteSession() { |
| return ::mozc::session::testing::DeleteSession(handler_.get(), id_); |
| } |
| |
| bool TestSessionClient::CleanUp() { |
| return ::mozc::session::testing::CleanUp(handler_.get(), id_); |
| } |
| |
| bool TestSessionClient::ClearUserPrediction() { |
| return ::mozc::session::testing::ClearUserPrediction(handler_.get(), id_); |
| } |
| |
| bool TestSessionClient::SendKeyWithOption(const commands::KeyEvent &key, |
| const commands::Input &option, |
| commands::Output *output) { |
| commands::Input input; |
| input.set_type(commands::Input::SEND_KEY); |
| input.mutable_key()->CopyFrom(key); |
| input.MergeFrom(option); |
| return EvalCommand(&input, output); |
| } |
| |
| bool TestSessionClient::TestSendKeyWithOption(const commands::KeyEvent &key, |
| const commands::Input &option, |
| commands::Output *output) { |
| commands::Input input; |
| input.set_type(commands::Input::TEST_SEND_KEY); |
| input.mutable_key()->CopyFrom(key); |
| input.MergeFrom(option); |
| return EvalCommand(&input, output); |
| } |
| |
| bool TestSessionClient::SelectCandidate(uint32 id, commands::Output *output) { |
| commands::Input input; |
| input.set_type(commands::Input::SEND_COMMAND); |
| input.mutable_command()->set_type(commands::SessionCommand::SELECT_CANDIDATE); |
| input.mutable_command()->set_id(id); |
| return EvalCommand(&input, output); |
| } |
| |
| bool TestSessionClient::SubmitCandidate(uint32 id, commands::Output *output) { |
| commands::Input input; |
| input.set_type(commands::Input::SEND_COMMAND); |
| input.mutable_command()->set_type(commands::SessionCommand::SUBMIT_CANDIDATE); |
| input.mutable_command()->set_id(id); |
| return EvalCommand(&input, output); |
| } |
| |
| bool TestSessionClient::Reload() { |
| commands::Input input; |
| input.set_type(commands::Input::RELOAD); |
| return EvalCommand(&input, NULL); |
| } |
| |
| bool TestSessionClient::ResetContext() { |
| commands::Input input; |
| input.set_type(commands::Input::SEND_COMMAND); |
| input.mutable_command()->set_type(commands::SessionCommand::RESET_CONTEXT); |
| return EvalCommand(&input, NULL); |
| } |
| |
| bool TestSessionClient::UndoOrRewind(commands::Output *output) { |
| commands::Input input; |
| input.set_type(commands::Input::SEND_COMMAND); |
| input.mutable_command()->set_type(commands::SessionCommand::UNDO_OR_REWIND); |
| return EvalCommand(&input, output); |
| } |
| |
| bool TestSessionClient::SwitchInputMode( |
| commands::CompositionMode composition_mode) { |
| commands::Input input; |
| input.set_type(commands::Input::SEND_COMMAND); |
| input.mutable_command()->set_type( |
| commands::SessionCommand::SWITCH_INPUT_MODE); |
| input.mutable_command()->set_composition_mode(composition_mode); |
| return EvalCommand(&input, NULL); |
| } |
| |
| bool TestSessionClient::SetRequest(const commands::Request &request, |
| commands::Output *output) { |
| commands::Input input; |
| input.set_type(commands::Input::SET_REQUEST); |
| input.mutable_request()->CopyFrom(request); |
| return EvalCommand(&input, output); |
| } |
| |
| void TestSessionClient::SetCallbackText(const string &text) { |
| callback_text_ = text; |
| } |
| |
| bool TestSessionClient::EvalCommandInternal(commands::Input *input, |
| commands::Output *output, |
| bool allow_callback) { |
| input->set_id(id_); |
| commands::Command command; |
| command.mutable_input()->CopyFrom(*input); |
| bool result = handler_->EvalCommand(&command); |
| if (result && output != NULL) { |
| output->CopyFrom(command.output()); |
| } |
| |
| // If callback is allowed and the callback field exists, evaluate the callback |
| // command. |
| if (result && |
| allow_callback && |
| command.output().has_callback() && |
| command.output().callback().has_session_command()) { |
| commands::Input input2; |
| input2.set_type(commands::Input::SEND_COMMAND); |
| input2.mutable_command()->CopyFrom( |
| command.output().callback().session_command()); |
| input2.mutable_command()->set_text(callback_text_); |
| // Disallow further recursion. |
| result = EvalCommandInternal(&input2, output, false); |
| } |
| callback_text_.clear(); |
| return result; |
| } |
| |
| bool TestSessionClient::EvalCommand(commands::Input *input, |
| commands::Output *output) { |
| return EvalCommandInternal(input, output, true); |
| } |
| |
| } // namespace testing |
| } // namespace session |
| } // namespace mozc |