OLD | NEW |
1 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved. | 1 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <unistd.h> | 5 #include <unistd.h> |
6 #include <string> | 6 #include <string> |
7 #include <vector> | 7 #include <vector> |
8 #include <base/scoped_ptr.h> | 8 #include <base/scoped_ptr.h> |
9 #include <glib.h> | 9 #include <glib.h> |
10 #include <gtest/gtest.h> | 10 #include <gtest/gtest.h> |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
99 } | 99 } |
100 free(argv[0]); | 100 free(argv[0]); |
101 return; | 101 return; |
102 } | 102 } |
103 ~PythonHttpServer() { | 103 ~PythonHttpServer() { |
104 if (!started_) | 104 if (!started_) |
105 return; | 105 return; |
106 // request that the server exit itself | 106 // request that the server exit itself |
107 LOG(INFO) << "running wget to exit"; | 107 LOG(INFO) << "running wget to exit"; |
108 int rc = system((string("wget -t 1 --output-document=/dev/null ") + | 108 int rc = system((string("wget -t 1 --output-document=/dev/null ") + |
109 LocalServerUrlForPath("/quitquitquit")).c_str()); | 109 LocalServerUrlForPath("/quitquitquit")).c_str()); |
110 LOG(INFO) << "done running wget to exit"; | 110 LOG(INFO) << "done running wget to exit"; |
111 if (validate_quit_) | 111 if (validate_quit_) |
112 EXPECT_EQ(0, rc); | 112 EXPECT_EQ(0, rc); |
113 waitpid(pid_, NULL, 0); | 113 waitpid(pid_, NULL, 0); |
114 } | 114 } |
115 GPid pid_; | 115 GPid pid_; |
116 bool started_; | 116 bool started_; |
117 bool validate_quit_; | 117 bool validate_quit_; |
118 }; | 118 }; |
119 | 119 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
167 }; | 167 }; |
168 | 168 |
169 gboolean StartTransfer(gpointer data) { | 169 gboolean StartTransfer(gpointer data) { |
170 StartTransferArgs *args = reinterpret_cast<StartTransferArgs*>(data); | 170 StartTransferArgs *args = reinterpret_cast<StartTransferArgs*>(data); |
171 args->http_fetcher->BeginTransfer(args->url); | 171 args->http_fetcher->BeginTransfer(args->url); |
172 return FALSE; | 172 return FALSE; |
173 } | 173 } |
174 } // namespace {} | 174 } // namespace {} |
175 | 175 |
176 TYPED_TEST(HttpFetcherTest, SimpleTest) { | 176 TYPED_TEST(HttpFetcherTest, SimpleTest) { |
177 GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE); | 177 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
178 { | 178 { |
179 HttpFetcherTestDelegate delegate; | 179 HttpFetcherTestDelegate delegate; |
180 delegate.loop_ = loop; | 180 delegate.loop_ = loop; |
181 scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher()); | 181 scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher()); |
182 fetcher->set_delegate(&delegate); | 182 fetcher->set_delegate(&delegate); |
183 | 183 |
184 typename TestFixture::HttpServer server; | 184 typename TestFixture::HttpServer server; |
185 ASSERT_TRUE(server.started_); | 185 ASSERT_TRUE(server.started_); |
186 | 186 |
187 StartTransferArgs start_xfer_args = {fetcher.get(), this->SmallUrl()}; | 187 StartTransferArgs start_xfer_args = {fetcher.get(), this->SmallUrl()}; |
188 | 188 |
189 g_timeout_add(0, StartTransfer, &start_xfer_args); | 189 g_timeout_add(0, StartTransfer, &start_xfer_args); |
190 g_main_loop_run(loop); | 190 g_main_loop_run(loop); |
191 } | 191 } |
192 g_main_loop_unref(loop); | 192 g_main_loop_unref(loop); |
193 } | 193 } |
194 | 194 |
195 TYPED_TEST(HttpFetcherTest, SimpleBigTest) { | 195 TYPED_TEST(HttpFetcherTest, SimpleBigTest) { |
196 GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE); | 196 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
197 { | 197 { |
198 HttpFetcherTestDelegate delegate; | 198 HttpFetcherTestDelegate delegate; |
199 delegate.loop_ = loop; | 199 delegate.loop_ = loop; |
200 scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher()); | 200 scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher()); |
201 fetcher->set_delegate(&delegate); | 201 fetcher->set_delegate(&delegate); |
202 | 202 |
203 typename TestFixture::HttpServer server; | 203 typename TestFixture::HttpServer server; |
204 ASSERT_TRUE(server.started_); | 204 ASSERT_TRUE(server.started_); |
205 | 205 |
206 StartTransferArgs start_xfer_args = {fetcher.get(), this->BigUrl()}; | 206 StartTransferArgs start_xfer_args = {fetcher.get(), this->BigUrl()}; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
239 gboolean UnpausingTimeoutCallback(gpointer data) { | 239 gboolean UnpausingTimeoutCallback(gpointer data) { |
240 PausingHttpFetcherTestDelegate *delegate = | 240 PausingHttpFetcherTestDelegate *delegate = |
241 reinterpret_cast<PausingHttpFetcherTestDelegate*>(data); | 241 reinterpret_cast<PausingHttpFetcherTestDelegate*>(data); |
242 if (delegate->paused_) | 242 if (delegate->paused_) |
243 delegate->Unpause(); | 243 delegate->Unpause(); |
244 return TRUE; | 244 return TRUE; |
245 } | 245 } |
246 } // namespace {} | 246 } // namespace {} |
247 | 247 |
248 TYPED_TEST(HttpFetcherTest, PauseTest) { | 248 TYPED_TEST(HttpFetcherTest, PauseTest) { |
249 GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE); | 249 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
250 { | 250 { |
251 PausingHttpFetcherTestDelegate delegate; | 251 PausingHttpFetcherTestDelegate delegate; |
252 scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher()); | 252 scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher()); |
253 delegate.paused_ = false; | 253 delegate.paused_ = false; |
254 delegate.loop_ = loop; | 254 delegate.loop_ = loop; |
255 delegate.fetcher_ = fetcher.get(); | 255 delegate.fetcher_ = fetcher.get(); |
256 fetcher->set_delegate(&delegate); | 256 fetcher->set_delegate(&delegate); |
257 | 257 |
258 typename TestFixture::HttpServer server; | 258 typename TestFixture::HttpServer server; |
259 ASSERT_TRUE(server.started_); | 259 ASSERT_TRUE(server.started_); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 delegate->TerminateTransfer(); | 299 delegate->TerminateTransfer(); |
300 return TRUE; | 300 return TRUE; |
301 } else { | 301 } else { |
302 delegate->EndLoop(); | 302 delegate->EndLoop(); |
303 return FALSE; | 303 return FALSE; |
304 } | 304 } |
305 } | 305 } |
306 } // namespace {} | 306 } // namespace {} |
307 | 307 |
308 TYPED_TEST(HttpFetcherTest, AbortTest) { | 308 TYPED_TEST(HttpFetcherTest, AbortTest) { |
309 GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE); | 309 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
310 { | 310 { |
311 AbortingHttpFetcherTestDelegate delegate; | 311 AbortingHttpFetcherTestDelegate delegate; |
312 scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher()); | 312 scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher()); |
313 delegate.once_ = true; | 313 delegate.once_ = true; |
314 delegate.loop_ = loop; | 314 delegate.loop_ = loop; |
315 delegate.fetcher_ = fetcher.get(); | 315 delegate.fetcher_ = fetcher.get(); |
316 fetcher->set_delegate(&delegate); | 316 fetcher->set_delegate(&delegate); |
317 | 317 |
318 typename TestFixture::HttpServer server; | 318 typename TestFixture::HttpServer server; |
319 this->IgnoreServerAborting(&server); | 319 this->IgnoreServerAborting(&server); |
(...skipping 22 matching lines...) Expand all Loading... |
342 g_main_loop_quit(loop_); | 342 g_main_loop_quit(loop_); |
343 } | 343 } |
344 string data; | 344 string data; |
345 GMainLoop* loop_; | 345 GMainLoop* loop_; |
346 }; | 346 }; |
347 } // namespace {} | 347 } // namespace {} |
348 | 348 |
349 TYPED_TEST(HttpFetcherTest, FlakyTest) { | 349 TYPED_TEST(HttpFetcherTest, FlakyTest) { |
350 if (this->IsMock()) | 350 if (this->IsMock()) |
351 return; | 351 return; |
352 GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE); | 352 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
353 { | 353 { |
354 FlakyHttpFetcherTestDelegate delegate; | 354 FlakyHttpFetcherTestDelegate delegate; |
355 delegate.loop_ = loop; | 355 delegate.loop_ = loop; |
356 scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher()); | 356 scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher()); |
357 fetcher->set_delegate(&delegate); | 357 fetcher->set_delegate(&delegate); |
358 | 358 |
359 typename TestFixture::HttpServer server; | 359 typename TestFixture::HttpServer server; |
360 ASSERT_TRUE(server.started_); | 360 ASSERT_TRUE(server.started_); |
361 | 361 |
362 StartTransferArgs start_xfer_args = { | 362 StartTransferArgs start_xfer_args = { |
363 fetcher.get(), | 363 fetcher.get(), |
364 LocalServerUrlForPath("/flaky") | 364 LocalServerUrlForPath("/flaky") |
365 }; | 365 }; |
366 | 366 |
367 g_timeout_add(0, StartTransfer, &start_xfer_args); | 367 g_timeout_add(0, StartTransfer, &start_xfer_args); |
368 g_main_loop_run(loop); | 368 g_main_loop_run(loop); |
369 | 369 |
370 // verify the data we get back | 370 // verify the data we get back |
371 ASSERT_EQ(100000, delegate.data.size()); | 371 ASSERT_EQ(100000, delegate.data.size()); |
372 for (int i = 0; i < 100000; i += 10) { | 372 for (int i = 0; i < 100000; i += 10) { |
373 // Assert so that we don't flood the screen w/ EXPECT errors on failure. | 373 // Assert so that we don't flood the screen w/ EXPECT errors on failure. |
374 ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij"); | 374 ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij"); |
375 } | 375 } |
376 } | 376 } |
377 g_main_loop_unref(loop); | 377 g_main_loop_unref(loop); |
378 } | 378 } |
379 | 379 |
| 380 namespace { |
| 381 class FailureHttpFetcherTestDelegate : public HttpFetcherDelegate { |
| 382 public: |
| 383 FailureHttpFetcherTestDelegate() : loop_(NULL), server_(NULL) {} |
| 384 virtual void ReceivedBytes(HttpFetcher* fetcher, |
| 385 const char* bytes, int length) { |
| 386 if (server_) { |
| 387 LOG(INFO) << "Stopping server"; |
| 388 delete server_; |
| 389 LOG(INFO) << "server stopped"; |
| 390 server_ = NULL; |
| 391 } |
| 392 } |
| 393 virtual void TransferComplete(HttpFetcher* fetcher, bool successful) { |
| 394 EXPECT_FALSE(successful); |
| 395 g_main_loop_quit(loop_); |
| 396 } |
| 397 GMainLoop* loop_; |
| 398 PythonHttpServer* server_; |
| 399 }; |
| 400 } // namespace {} |
| 401 |
| 402 |
| 403 TYPED_TEST(HttpFetcherTest, FailureTest) { |
| 404 if (this->IsMock()) |
| 405 return; |
| 406 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 407 { |
| 408 FailureHttpFetcherTestDelegate delegate; |
| 409 delegate.loop_ = loop; |
| 410 scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher()); |
| 411 fetcher->set_delegate(&delegate); |
| 412 |
| 413 StartTransferArgs start_xfer_args = { |
| 414 fetcher.get(), |
| 415 LocalServerUrlForPath(this->SmallUrl()) |
| 416 }; |
| 417 |
| 418 g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 419 g_main_loop_run(loop); |
| 420 |
| 421 // Exiting and testing happens in the delegate |
| 422 } |
| 423 g_main_loop_unref(loop); |
| 424 } |
| 425 |
| 426 TYPED_TEST(HttpFetcherTest, ServerDiesTest) { |
| 427 if (this->IsMock()) |
| 428 return; |
| 429 GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE); |
| 430 { |
| 431 FailureHttpFetcherTestDelegate delegate; |
| 432 delegate.loop_ = loop; |
| 433 delegate.server_ = new PythonHttpServer; |
| 434 scoped_ptr<HttpFetcher> fetcher(this->NewSmallFetcher()); |
| 435 fetcher->set_delegate(&delegate); |
| 436 |
| 437 StartTransferArgs start_xfer_args = { |
| 438 fetcher.get(), |
| 439 LocalServerUrlForPath("/flaky") |
| 440 }; |
| 441 |
| 442 g_timeout_add(0, StartTransfer, &start_xfer_args); |
| 443 g_main_loop_run(loop); |
| 444 |
| 445 // Exiting and testing happens in the delegate |
| 446 } |
| 447 g_main_loop_unref(loop); |
| 448 } |
| 449 |
380 } // namespace chromeos_update_engine | 450 } // namespace chromeos_update_engine |
OLD | NEW |