AU: Changes for deltas on traditional bios machines.

http_fetcher_unittest.cc

 // Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <unistd.h>
 #include <string>
 #include <vector>
 #include <base/scoped_ptr.h>
 #include <glib.h>
 #include <gtest/gtest.h>
@@ skipping 64 matching lines @@
                        argv,
                        NULL,
                        G_SPAWN_DO_NOT_REAP_CHILD,
                        NULL,
                        NULL,
                        &pid_,
                        &err)) {
       return;
     }
     int rc = 1;
+    int tries = 10;
+    started_ = true;
     while (0 != rc) {
+      LOG(INFO) << "running wget to start";
       rc = system((string("wget --output-document=/dev/null ") +
                    LocalServerUrlForPath("/test")).c_str());
+      LOG(INFO) << "done running wget to start";
       usleep(10 * 1000);  // 10 ms
+      tries--;
+      if (tries == 0) {
+        LOG(ERROR) << "Unable to start server.";
+        started_ = false;
+        break;
+      }
     }
-    started_ = true;
     free(argv[0]);
     return;
   }
   ~PythonHttpServer() {
     if (!started_)
       return;
     // request that the server exit itself
+    LOG(INFO) << "running wget to exit";
     int rc = system((string("wget -t 1 --output-document=/dev/null ") +
                     LocalServerUrlForPath("/quitquitquit")).c_str());
+    LOG(INFO) << "done running wget to exit";
     if (validate_quit_)
       EXPECT_EQ(0, rc);
     waitpid(pid_, NULL, 0);
   }
   GPid pid_;
   bool started_;
   bool validate_quit_;
 };
 
 template <>
 class HttpFetcherTest<LibcurlHttpFetcher> : public ::testing::Test {
  public:
   HttpFetcher* NewLargeFetcher() {
     LibcurlHttpFetcher *ret = new LibcurlHttpFetcher;
-    ret->set_idle_ms(1);  // speeds up test execution
+    ret->set_idle_ms(1000);  // speeds up test execution
     return ret;
   }
   HttpFetcher* NewSmallFetcher() {
     return NewLargeFetcher();
   }
   string BigUrl() const {
     return LocalServerUrlForPath("/big");
   }
   string SmallUrl() const {
     return LocalServerUrlForPath("/foo");
@@ skipping 49 matching lines @@
     ASSERT_TRUE(server.started_);
 
     StartTransferArgs start_xfer_args = {fetcher.get(), this->SmallUrl()};
 
     g_timeout_add(0, StartTransfer, &start_xfer_args);
     g_main_loop_run(loop);
   }
   g_main_loop_unref(loop);
 }
 
+TYPED_TEST(HttpFetcherTest, SimpleBigTest) {
+  GMainLoop *loop = g_main_loop_new(g_main_context_default(), FALSE);
+  {
+    HttpFetcherTestDelegate delegate;
+    delegate.loop_ = loop;
+    scoped_ptr<HttpFetcher> fetcher(this->NewLargeFetcher());
+    fetcher->set_delegate(&delegate);
+
+    typename TestFixture::HttpServer server;
+    ASSERT_TRUE(server.started_);
+
+    StartTransferArgs start_xfer_args = {fetcher.get(), this->BigUrl()};
+
+    g_timeout_add(0, StartTransfer, &start_xfer_args);
+    g_main_loop_run(loop);
+  }
+  g_main_loop_unref(loop);
+}
+
 namespace {
 class PausingHttpFetcherTestDelegate : public HttpFetcherDelegate {
  public:
   virtual void ReceivedBytes(HttpFetcher* fetcher,
                              const char* bytes, int length) {
     char str[length + 1];
     memset(str, 0, length + 1);
     memcpy(str, bytes, length);
     CHECK(!paused_);
     paused_ = true;
@@ skipping 147 matching lines @@
     ASSERT_EQ(100000, delegate.data.size());
     for (int i = 0; i < 100000; i += 10) {
       // Assert so that we don't flood the screen w/ EXPECT errors on failure.
       ASSERT_EQ(delegate.data.substr(i, 10), "abcdefghij");
     }
   }
   g_main_loop_unref(loop);
 }
 
 }  // namespace chromeos_update_engine