| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/common/chrome_constants.h" | |
| 6 #include "chrome/renderer/translate_helper.h" | |
| 7 #include "chrome/test/render_view_test.h" | |
| 8 #include "testing/gmock/include/gmock/gmock.h" | |
| 9 #include "testing/gtest/include/gtest/gtest.h" | |
| 10 | |
| 11 using testing::AtLeast; | |
| 12 using testing::Return; | |
| 13 | |
| 14 class TestTranslateHelper : public TranslateHelper { | |
| 15 public: | |
| 16 explicit TestTranslateHelper(RenderView* render_view) | |
| 17 : TranslateHelper(render_view) { | |
| 18 } | |
| 19 | |
| 20 virtual bool DontDelayTasks() { return true; } | |
| 21 | |
| 22 MOCK_METHOD0(IsTranslateLibAvailable, bool()); | |
| 23 MOCK_METHOD0(IsTranslateLibReady, bool()); | |
| 24 MOCK_METHOD0(HasTranslationFinished, bool()); | |
| 25 MOCK_METHOD0(HasTranslationFailed, bool()); | |
| 26 MOCK_METHOD0(GetOriginalPageLanguage, std::string()); | |
| 27 MOCK_METHOD0(StartTranslation, bool()); | |
| 28 | |
| 29 private: | |
| 30 DISALLOW_COPY_AND_ASSIGN(TestTranslateHelper); | |
| 31 }; | |
| 32 | |
| 33 class TranslateHelperTest : public RenderViewTest { | |
| 34 public: | |
| 35 TranslateHelperTest() {} | |
| 36 | |
| 37 protected: | |
| 38 virtual void SetUp() { | |
| 39 RenderViewTest::SetUp(); | |
| 40 translate_helper_.reset(new TestTranslateHelper(view_)); | |
| 41 } | |
| 42 | |
| 43 bool GetPageTranslatedMessage(int* page_id, | |
| 44 std::string* original_lang, | |
| 45 std::string* target_lang, | |
| 46 TranslateErrors::Type* error) { | |
| 47 const IPC::Message* message = render_thread_.sink(). | |
| 48 GetUniqueMessageMatching(ViewHostMsg_PageTranslated::ID); | |
| 49 if (!message) | |
| 50 return false; | |
| 51 Tuple4<int, std::string, std::string, TranslateErrors::Type> | |
| 52 translate_param; | |
| 53 ViewHostMsg_PageTranslated::Read(message, &translate_param); | |
| 54 if (page_id) | |
| 55 *page_id = translate_param.a; | |
| 56 if (original_lang) | |
| 57 *original_lang = translate_param.b; | |
| 58 if (target_lang) | |
| 59 *target_lang = translate_param.c; | |
| 60 if (error) | |
| 61 *error = translate_param.d; | |
| 62 return true; | |
| 63 } | |
| 64 | |
| 65 scoped_ptr<TestTranslateHelper> translate_helper_; | |
| 66 }; | |
| 67 | |
| 68 // Tests that the browser gets notified of the translation failure if the | |
| 69 // translate library fails/times-out during initialization. | |
| 70 TEST_F(TranslateHelperTest, TranslateLibNeverReady) { | |
| 71 // We make IsTranslateLibAvailable true so we don't attempt to inject the | |
| 72 // library. | |
| 73 EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable()) | |
| 74 .Times(AtLeast(1)) | |
| 75 .WillRepeatedly(Return(true)); | |
| 76 | |
| 77 EXPECT_CALL(*translate_helper_, IsTranslateLibReady()) | |
| 78 .Times(AtLeast(5)) // See kMaxTranslateInitCheckAttempts in | |
| 79 // translate_helper.cc | |
| 80 .WillRepeatedly(Return(false)); | |
| 81 | |
| 82 translate_helper_->TranslatePage(view_->page_id(), "en", "fr", std::string()); | |
| 83 MessageLoop::current()->RunAllPending(); | |
| 84 | |
| 85 int page_id; | |
| 86 TranslateErrors::Type error; | |
| 87 ASSERT_TRUE(GetPageTranslatedMessage(&page_id, NULL, NULL, &error)); | |
| 88 EXPECT_EQ(view_->page_id(), page_id); | |
| 89 EXPECT_EQ(TranslateErrors::INITIALIZATION_ERROR, error); | |
| 90 } | |
| 91 | |
| 92 // Tests that the browser gets notified of the translation success when the | |
| 93 // translation succeeds. | |
| 94 TEST_F(TranslateHelperTest, TranslateSuccess) { | |
| 95 // We make IsTranslateLibAvailable true so we don't attempt to inject the | |
| 96 // library. | |
| 97 EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable()) | |
| 98 .Times(AtLeast(1)) | |
| 99 .WillRepeatedly(Return(true)); | |
| 100 | |
| 101 EXPECT_CALL(*translate_helper_, IsTranslateLibReady()) | |
| 102 .WillOnce(Return(false)) | |
| 103 .WillOnce(Return(true)); | |
| 104 | |
| 105 EXPECT_CALL(*translate_helper_, StartTranslation()).WillOnce(Return(true)); | |
| 106 | |
| 107 // Succeed after few checks. | |
| 108 EXPECT_CALL(*translate_helper_, HasTranslationFailed()) | |
| 109 .WillRepeatedly(Return(false)); | |
| 110 EXPECT_CALL(*translate_helper_, HasTranslationFinished()) | |
| 111 .WillOnce(Return(false)) | |
| 112 .WillOnce(Return(false)) | |
| 113 .WillOnce(Return(true)); | |
| 114 | |
| 115 std::string original_lang("en"); | |
| 116 std::string target_lang("fr"); | |
| 117 translate_helper_->TranslatePage(view_->page_id(), original_lang, target_lang, | |
| 118 std::string()); | |
| 119 MessageLoop::current()->RunAllPending(); | |
| 120 | |
| 121 int page_id; | |
| 122 std::string received_original_lang; | |
| 123 std::string received_target_lang; | |
| 124 TranslateErrors::Type error; | |
| 125 ASSERT_TRUE(GetPageTranslatedMessage(&page_id, | |
| 126 &received_original_lang, | |
| 127 &received_target_lang, | |
| 128 &error)); | |
| 129 EXPECT_EQ(view_->page_id(), page_id); | |
| 130 EXPECT_EQ(original_lang, received_original_lang); | |
| 131 EXPECT_EQ(target_lang, received_target_lang); | |
| 132 EXPECT_EQ(TranslateErrors::NONE, error); | |
| 133 } | |
| 134 | |
| 135 // Tests that the browser gets notified of the translation failure when the | |
| 136 // translation fails. | |
| 137 TEST_F(TranslateHelperTest, TranslateFailure) { | |
| 138 // We make IsTranslateLibAvailable true so we don't attempt to inject the | |
| 139 // library. | |
| 140 EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable()) | |
| 141 .Times(AtLeast(1)) | |
| 142 .WillRepeatedly(Return(true)); | |
| 143 | |
| 144 EXPECT_CALL(*translate_helper_, IsTranslateLibReady()) | |
| 145 .WillOnce(Return(true)); | |
| 146 | |
| 147 EXPECT_CALL(*translate_helper_, StartTranslation()).WillOnce(Return(true)); | |
| 148 | |
| 149 // Fail after few checks. | |
| 150 EXPECT_CALL(*translate_helper_, HasTranslationFailed()) | |
| 151 .WillOnce(Return(false)) | |
| 152 .WillOnce(Return(false)) | |
| 153 .WillOnce(Return(false)) | |
| 154 .WillOnce(Return(true)); | |
| 155 | |
| 156 EXPECT_CALL(*translate_helper_, HasTranslationFinished()) | |
| 157 .Times(AtLeast(1)) | |
| 158 .WillRepeatedly(Return(false)); | |
| 159 | |
| 160 translate_helper_->TranslatePage(view_->page_id(), "en", "fr", std::string()); | |
| 161 MessageLoop::current()->RunAllPending(); | |
| 162 | |
| 163 int page_id; | |
| 164 TranslateErrors::Type error; | |
| 165 ASSERT_TRUE(GetPageTranslatedMessage(&page_id, NULL, NULL, &error)); | |
| 166 EXPECT_EQ(view_->page_id(), page_id); | |
| 167 EXPECT_EQ(TranslateErrors::TRANSLATION_ERROR, error); | |
| 168 } | |
| 169 | |
| 170 // Tests that when the browser translate a page for which the language is | |
| 171 // undefined we query the translate element to get the language. | |
| 172 TEST_F(TranslateHelperTest, UndefinedSourceLang) { | |
| 173 // We make IsTranslateLibAvailable true so we don't attempt to inject the | |
| 174 // library. | |
| 175 EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable()) | |
| 176 .Times(AtLeast(1)) | |
| 177 .WillRepeatedly(Return(true)); | |
| 178 | |
| 179 EXPECT_CALL(*translate_helper_, IsTranslateLibReady()) | |
| 180 .WillOnce(Return(true)); | |
| 181 | |
| 182 EXPECT_CALL(*translate_helper_, GetOriginalPageLanguage()) | |
| 183 .WillOnce(Return("de")); | |
| 184 | |
| 185 EXPECT_CALL(*translate_helper_, StartTranslation()).WillOnce(Return(true)); | |
| 186 EXPECT_CALL(*translate_helper_, HasTranslationFailed()) | |
| 187 .WillOnce(Return(false)); | |
| 188 EXPECT_CALL(*translate_helper_, HasTranslationFinished()) | |
| 189 .Times(AtLeast(1)) | |
| 190 .WillRepeatedly(Return(true)); | |
| 191 | |
| 192 translate_helper_->TranslatePage(view_->page_id(), | |
| 193 chrome::kUnknownLanguageCode, "fr", | |
| 194 std::string()); | |
| 195 MessageLoop::current()->RunAllPending(); | |
| 196 | |
| 197 int page_id; | |
| 198 TranslateErrors::Type error; | |
| 199 std::string original_lang; | |
| 200 std::string target_lang; | |
| 201 ASSERT_TRUE(GetPageTranslatedMessage(&page_id, &original_lang, &target_lang, | |
| 202 &error)); | |
| 203 EXPECT_EQ(view_->page_id(), page_id); | |
| 204 EXPECT_EQ("de", original_lang); | |
| 205 EXPECT_EQ("fr", target_lang); | |
| 206 EXPECT_EQ(TranslateErrors::NONE, error); | |
| 207 } | |
| 208 | |
| 209 // Tests that starting a translation while a similar one is pending does not | |
| 210 // break anything. | |
| 211 TEST_F(TranslateHelperTest, MultipleSimilarTranslations) { | |
| 212 // We make IsTranslateLibAvailable true so we don't attempt to inject the | |
| 213 // library. | |
| 214 EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable()) | |
| 215 .Times(AtLeast(1)) | |
| 216 .WillRepeatedly(Return(true)); | |
| 217 | |
| 218 EXPECT_CALL(*translate_helper_, IsTranslateLibReady()) | |
| 219 .WillRepeatedly(Return(true)); | |
| 220 EXPECT_CALL(*translate_helper_, StartTranslation()) | |
| 221 .WillRepeatedly(Return(true)); | |
| 222 EXPECT_CALL(*translate_helper_, HasTranslationFailed()) | |
| 223 .WillRepeatedly(Return(false)); | |
| 224 EXPECT_CALL(*translate_helper_, HasTranslationFinished()) | |
| 225 .WillOnce(Return(true)); | |
| 226 | |
| 227 std::string original_lang("en"); | |
| 228 std::string target_lang("fr"); | |
| 229 translate_helper_->TranslatePage(view_->page_id(), original_lang, target_lang, | |
| 230 std::string()); | |
| 231 // While this is running call again TranslatePage to make sure noting bad | |
| 232 // happens. | |
| 233 translate_helper_->TranslatePage(view_->page_id(), original_lang, target_lang, | |
| 234 std::string()); | |
| 235 MessageLoop::current()->RunAllPending(); | |
| 236 | |
| 237 int page_id; | |
| 238 std::string received_original_lang; | |
| 239 std::string received_target_lang; | |
| 240 TranslateErrors::Type error; | |
| 241 ASSERT_TRUE(GetPageTranslatedMessage(&page_id, | |
| 242 &received_original_lang, | |
| 243 &received_target_lang, | |
| 244 &error)); | |
| 245 EXPECT_EQ(view_->page_id(), page_id); | |
| 246 EXPECT_EQ(original_lang, received_original_lang); | |
| 247 EXPECT_EQ(target_lang, received_target_lang); | |
| 248 EXPECT_EQ(TranslateErrors::NONE, error); | |
| 249 } | |
| 250 | |
| 251 // Tests that starting a translation while a different one is pending works. | |
| 252 TEST_F(TranslateHelperTest, MultipleDifferentTranslations) { | |
| 253 EXPECT_CALL(*translate_helper_, IsTranslateLibAvailable()) | |
| 254 .Times(AtLeast(1)) | |
| 255 .WillRepeatedly(Return(true)); | |
| 256 EXPECT_CALL(*translate_helper_, IsTranslateLibReady()) | |
| 257 .WillRepeatedly(Return(true)); | |
| 258 EXPECT_CALL(*translate_helper_, StartTranslation()) | |
| 259 .WillRepeatedly(Return(true)); | |
| 260 EXPECT_CALL(*translate_helper_, HasTranslationFailed()) | |
| 261 .WillRepeatedly(Return(false)); | |
| 262 EXPECT_CALL(*translate_helper_, HasTranslationFinished()) | |
| 263 .WillOnce(Return(true)); | |
| 264 | |
| 265 std::string original_lang("en"); | |
| 266 std::string target_lang("fr"); | |
| 267 translate_helper_->TranslatePage(view_->page_id(), original_lang, target_lang, | |
| 268 std::string()); | |
| 269 // While this is running call again TranslatePage with a new target lang. | |
| 270 std::string new_target_lang("de"); | |
| 271 translate_helper_->TranslatePage(view_->page_id(), original_lang, | |
| 272 new_target_lang, std::string()); | |
| 273 MessageLoop::current()->RunAllPending(); | |
| 274 | |
| 275 int page_id; | |
| 276 std::string received_original_lang; | |
| 277 std::string received_target_lang; | |
| 278 TranslateErrors::Type error; | |
| 279 ASSERT_TRUE(GetPageTranslatedMessage(&page_id, | |
| 280 &received_original_lang, | |
| 281 &received_target_lang, | |
| 282 &error)); | |
| 283 EXPECT_EQ(view_->page_id(), page_id); | |
| 284 EXPECT_EQ(original_lang, received_original_lang); | |
| 285 EXPECT_EQ(new_target_lang, received_target_lang); | |
| 286 EXPECT_EQ(TranslateErrors::NONE, error); | |
| 287 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3150034:
GTTF: move tests that use WebKit from unit_tests to browser_tests... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/