net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc

   1 // Copyright (c) 2012 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 "net/proxy/dhcp_proxy_script_fetcher_win.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/rand_util.h"
  13 #include "base/test/test_timeouts.h"
  14 #include "base/threading/platform_thread.h"
  15 #include "base/timer/elapsed_timer.h"
  16 #include "net/base/completion_callback.h"
  17 #include "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
  18 #include "net/url_request/url_request_test_util.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace net {
  22
  23 namespace {
  24
  25 TEST(DhcpProxyScriptFetcherWin, AdapterNamesAndPacURLFromDhcp) {
  26   // This tests our core Win32 implementation without any of the wrappers
  27   // we layer on top to achieve asynchronous and parallel operations.
  28   //
  29   // We don't make assumptions about the environment this unit test is
  30   // running in, so it just exercises the code to make sure there
  31   // is no crash and no error returned, but does not assert on the number
  32   // of interfaces or the information returned via DHCP.
  33   std::set<std::string> adapter_names;
  34   DhcpProxyScriptFetcherWin::GetCandidateAdapterNames(&adapter_names);
  35   for (std::set<std::string>::const_iterator it = adapter_names.begin();
  36        it != adapter_names.end();
  37        ++it) {
  38     const std::string& adapter_name = *it;
  39     std::string pac_url =
  40         DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(adapter_name);
  41     printf("Adapter '%s' has PAC URL '%s' configured in DHCP.\n",
  42            adapter_name.c_str(),
  43            pac_url.c_str());
  44   }
  45 }
  46
  47 // Helper for RealFetch* tests below.
  48 class RealFetchTester {
  49  public:
  50   RealFetchTester()
  51       : context_(new TestURLRequestContext),
  52         fetcher_(new DhcpProxyScriptFetcherWin(context_.get())),
  53         finished_(false),
  54         on_completion_is_error_(false) {
  55     // Make sure the test ends.
  56     timeout_.Start(FROM_HERE,
  57         base::TimeDelta::FromSeconds(5), this, &RealFetchTester::OnTimeout);
  58   }
  59
  60   void RunTest() {
  61     int result = fetcher_->Fetch(
  62         &pac_text_,
  63         base::Bind(&RealFetchTester::OnCompletion, base::Unretained(this)));
  64     if (result != ERR_IO_PENDING)
  65       finished_ = true;
  66   }
  67
  68   void RunTestWithCancel() {
  69     RunTest();
  70     fetcher_->Cancel();
  71   }
  72
  73   void RunTestWithDeferredCancel() {
  74     // Put the cancellation into the queue before even running the
  75     // test to avoid the chance of one of the adapter fetcher worker
  76     // threads completing before cancellation.  See http://crbug.com/86756.
  77     cancel_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(0),
  78                         this, &RealFetchTester::OnCancelTimer);
  79     RunTest();
  80   }
  81
  82   void OnCompletion(int result) {
  83     if (on_completion_is_error_) {
  84       FAIL() << "Received completion for test in which this is error.";
  85     }
  86     finished_ = true;
  87     printf("Result code %d PAC data length %d\n", result, pac_text_.size());
  88   }
  89
  90   void OnTimeout() {
  91     printf("Timeout!");
  92     OnCompletion(0);
  93   }
  94
  95   void OnCancelTimer() {
  96     fetcher_->Cancel();
  97     finished_ = true;
  98   }
  99
 100   void WaitUntilDone() {
 101     while (!finished_) {
 102       base::MessageLoop::current()->RunUntilIdle();
 103     }
 104     base::MessageLoop::current()->RunUntilIdle();
 105   }
 106
 107   // Attempts to give worker threads time to finish.  This is currently
 108   // very simplistic as completion (via completion callback or cancellation)
 109   // immediately "detaches" any worker threads, so the best we can do is give
 110   // them a little time.  If we start running into Valgrind leaks, we can
 111   // do something a bit more clever to track worker threads even when the
 112   // DhcpProxyScriptFetcherWin state machine has finished.
 113   void FinishTestAllowCleanup() {
 114     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(30));
 115   }
 116
 117   scoped_ptr<URLRequestContext> context_;
 118   scoped_ptr<DhcpProxyScriptFetcherWin> fetcher_;
 119   bool finished_;
 120   base::string16 pac_text_;
 121   base::OneShotTimer<RealFetchTester> timeout_;
 122   base::OneShotTimer<RealFetchTester> cancel_timer_;
 123   bool on_completion_is_error_;
 124 };
 125
 126 TEST(DhcpProxyScriptFetcherWin, RealFetch) {
 127   // This tests a call to Fetch() with no stubbing out of dependencies.
 128   //
 129   // We don't make assumptions about the environment this unit test is
 130   // running in, so it just exercises the code to make sure there
 131   // is no crash and no unexpected error returned, but does not assert on
 132   // results beyond that.
 133   RealFetchTester fetcher;
 134   fetcher.RunTest();
 135
 136   fetcher.WaitUntilDone();
 137   printf("PAC URL was %s\n",
 138       fetcher.fetcher_->GetPacURL().possibly_invalid_spec().c_str());
 139
 140   fetcher.FinishTestAllowCleanup();
 141 }
 142
 143 TEST(DhcpProxyScriptFetcherWin, RealFetchWithCancel) {
 144   // Does a Fetch() with an immediate cancel.  As before, just
 145   // exercises the code without stubbing out dependencies.
 146   RealFetchTester fetcher;
 147   fetcher.RunTestWithCancel();
 148   base::MessageLoop::current()->RunUntilIdle();
 149
 150   // Attempt to avoid Valgrind leak reports in case worker thread is
 151   // still running.
 152   fetcher.FinishTestAllowCleanup();
 153 }
 154
 155 // For RealFetchWithDeferredCancel, below.
 156 class DelayingDhcpProxyScriptAdapterFetcher
 157     : public DhcpProxyScriptAdapterFetcher {
 158  public:
 159   DelayingDhcpProxyScriptAdapterFetcher(
 160       URLRequestContext* url_request_context,
 161       scoped_refptr<base::TaskRunner> task_runner)
 162       : DhcpProxyScriptAdapterFetcher(url_request_context, task_runner) {
 163   }
 164
 165   class DelayingDhcpQuery : public DhcpQuery {
 166    public:
 167     explicit DelayingDhcpQuery()
 168         : DhcpQuery() {
 169     }
 170
 171     std::string ImplGetPacURLFromDhcp(
 172         const std::string& adapter_name) OVERRIDE {
 173       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
 174       return DhcpQuery::ImplGetPacURLFromDhcp(adapter_name);
 175     }
 176   };
 177
 178   DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
 179     return new DelayingDhcpQuery();
 180   }
 181 };
 182
 183 // For RealFetchWithDeferredCancel, below.
 184 class DelayingDhcpProxyScriptFetcherWin
 185     : public DhcpProxyScriptFetcherWin {
 186  public:
 187   explicit DelayingDhcpProxyScriptFetcherWin(
 188       URLRequestContext* context)
 189       : DhcpProxyScriptFetcherWin(context) {
 190   }
 191
 192   DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
 193     return new DelayingDhcpProxyScriptAdapterFetcher(url_request_context(),
 194                                                      GetTaskRunner());
 195   }
 196 };
 197
 198 TEST(DhcpProxyScriptFetcherWin, RealFetchWithDeferredCancel) {
 199   // Does a Fetch() with a slightly delayed cancel.  As before, just
 200   // exercises the code without stubbing out dependencies, but
 201   // introduces a guaranteed 20 ms delay on the worker threads so that
 202   // the cancel is called before they complete.
 203   RealFetchTester fetcher;
 204   fetcher.fetcher_.reset(
 205       new DelayingDhcpProxyScriptFetcherWin(fetcher.context_.get()));
 206   fetcher.on_completion_is_error_ = true;
 207   fetcher.RunTestWithDeferredCancel();
 208   fetcher.WaitUntilDone();
 209 }
 210
 211 // The remaining tests are to exercise our state machine in various
 212 // situations, with actual network access fully stubbed out.
 213
 214 class DummyDhcpProxyScriptAdapterFetcher
 215     : public DhcpProxyScriptAdapterFetcher {
 216  public:
 217   DummyDhcpProxyScriptAdapterFetcher(URLRequestContext* context,
 218                                      scoped_refptr<base::TaskRunner> runner)
 219       : DhcpProxyScriptAdapterFetcher(context, runner),
 220         did_finish_(false),
 221         result_(OK),
 222         pac_script_(L"bingo"),
 223         fetch_delay_ms_(1) {
 224   }
 225
 226   void Fetch(const std::string& adapter_name,
 227              const CompletionCallback& callback) OVERRIDE {
 228     callback_ = callback;
 229     timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(fetch_delay_ms_),
 230                  this, &DummyDhcpProxyScriptAdapterFetcher::OnTimer);
 231   }
 232
 233   void Cancel() OVERRIDE {
 234     timer_.Stop();
 235   }
 236
 237   bool DidFinish() const OVERRIDE {
 238     return did_finish_;
 239   }
 240
 241   int GetResult() const OVERRIDE {
 242     return result_;
 243   }
 244
 245   base::string16 GetPacScript() const OVERRIDE {
 246     return pac_script_;
 247   }
 248
 249   void OnTimer() {
 250     callback_.Run(result_);
 251   }
 252
 253   void Configure(bool did_finish,
 254                  int result,
 255                  base::string16 pac_script,
 256                  int fetch_delay_ms) {
 257     did_finish_ = did_finish;
 258     result_ = result;
 259     pac_script_ = pac_script;
 260     fetch_delay_ms_ = fetch_delay_ms;
 261   }
 262
 263  private:
 264   bool did_finish_;
 265   int result_;
 266   base::string16 pac_script_;
 267   int fetch_delay_ms_;
 268   CompletionCallback callback_;
 269   base::OneShotTimer<DummyDhcpProxyScriptAdapterFetcher> timer_;
 270 };
 271
 272 class MockDhcpProxyScriptFetcherWin : public DhcpProxyScriptFetcherWin {
 273  public:
 274   class MockAdapterQuery : public AdapterQuery {
 275    public:
 276     MockAdapterQuery() {
 277     }
 278
 279     virtual ~MockAdapterQuery() {
 280     }
 281
 282     virtual bool ImplGetCandidateAdapterNames(
 283         std::set<std::string>* adapter_names) OVERRIDE {
 284       adapter_names->insert(
 285           mock_adapter_names_.begin(), mock_adapter_names_.end());
 286       return true;
 287     }
 288
 289     std::vector<std::string> mock_adapter_names_;
 290   };
 291
 292   MockDhcpProxyScriptFetcherWin(URLRequestContext* context)
 293       : DhcpProxyScriptFetcherWin(context),
 294         num_fetchers_created_(0),
 295         worker_finished_event_(true, false) {
 296     ResetTestState();
 297   }
 298
 299   virtual ~MockDhcpProxyScriptFetcherWin() {
 300     ResetTestState();
 301   }
 302
 303   using DhcpProxyScriptFetcherWin::GetTaskRunner;
 304
 305   // Adds a fetcher object to the queue of fetchers used by
 306   // |ImplCreateAdapterFetcher()|, and its name to the list of adapters
 307   // returned by ImplGetCandidateAdapterNames.
 308   void PushBackAdapter(const std::string& adapter_name,
 309                        DhcpProxyScriptAdapterFetcher* fetcher) {
 310     adapter_query_->mock_adapter_names_.push_back(adapter_name);
 311     adapter_fetchers_.push_back(fetcher);
 312   }
 313
 314   void ConfigureAndPushBackAdapter(const std::string& adapter_name,
 315                                    bool did_finish,
 316                                    int result,
 317                                    base::string16 pac_script,
 318                                    base::TimeDelta fetch_delay) {
 319     scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
 320         new DummyDhcpProxyScriptAdapterFetcher(url_request_context(),
 321                                                GetTaskRunner()));
 322     adapter_fetcher->Configure(
 323         did_finish, result, pac_script, fetch_delay.InMilliseconds());
 324     PushBackAdapter(adapter_name, adapter_fetcher.release());
 325   }
 326
 327   DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
 328     ++num_fetchers_created_;
 329     return adapter_fetchers_[next_adapter_fetcher_index_++];
 330   }
 331
 332   virtual AdapterQuery* ImplCreateAdapterQuery() OVERRIDE {
 333     DCHECK(adapter_query_);
 334     return adapter_query_.get();
 335   }
 336
 337   base::TimeDelta ImplGetMaxWait() OVERRIDE {
 338     return max_wait_;
 339   }
 340
 341   void ImplOnGetCandidateAdapterNamesDone() OVERRIDE {
 342     worker_finished_event_.Signal();
 343   }
 344
 345   void ResetTestState() {
 346     // Delete any adapter fetcher objects we didn't hand out.
 347     std::vector<DhcpProxyScriptAdapterFetcher*>::const_iterator it
 348         = adapter_fetchers_.begin();
 349     for (; it != adapter_fetchers_.end(); ++it) {
 350       if (num_fetchers_created_-- <= 0) {
 351         delete (*it);
 352       }
 353     }
 354
 355     next_adapter_fetcher_index_ = 0;
 356     num_fetchers_created_ = 0;
 357     adapter_fetchers_.clear();
 358     adapter_query_ = new MockAdapterQuery();
 359     max_wait_ = TestTimeouts::tiny_timeout();
 360   }
 361
 362   bool HasPendingFetchers() {
 363     return num_pending_fetchers() > 0;
 364   }
 365
 366   int next_adapter_fetcher_index_;
 367
 368   // Ownership gets transferred to the implementation class via
 369   // ImplCreateAdapterFetcher, but any objects not handed out are
 370   // deleted on destruction.
 371   std::vector<DhcpProxyScriptAdapterFetcher*> adapter_fetchers_;
 372
 373   scoped_refptr<MockAdapterQuery> adapter_query_;
 374
 375   base::TimeDelta max_wait_;
 376   int num_fetchers_created_;
 377   base::WaitableEvent worker_finished_event_;
 378 };
 379
 380 class FetcherClient {
 381  public:
 382   FetcherClient()
 383       : context_(new TestURLRequestContext),
 384         fetcher_(context_.get()),
 385         finished_(false),
 386         result_(ERR_UNEXPECTED) {
 387   }
 388
 389   void RunTest() {
 390     int result = fetcher_.Fetch(
 391         &pac_text_,
 392         base::Bind(&FetcherClient::OnCompletion, base::Unretained(this)));
 393     ASSERT_EQ(ERR_IO_PENDING, result);
 394   }
 395
 396   void RunMessageLoopUntilComplete() {
 397     while (!finished_) {
 398       base::MessageLoop::current()->RunUntilIdle();
 399     }
 400     base::MessageLoop::current()->RunUntilIdle();
 401   }
 402
 403   void RunMessageLoopUntilWorkerDone() {
 404     DCHECK(fetcher_.adapter_query_.get());
 405     while (!fetcher_.worker_finished_event_.TimedWait(
 406         base::TimeDelta::FromMilliseconds(10))) {
 407       base::MessageLoop::current()->RunUntilIdle();
 408     }
 409   }
 410
 411   void OnCompletion(int result) {
 412     finished_ = true;
 413     result_ = result;
 414   }
 415
 416   void ResetTestState() {
 417     finished_ = false;
 418     result_ = ERR_UNEXPECTED;
 419     pac_text_ = L"";
 420     fetcher_.ResetTestState();
 421   }
 422
 423   scoped_refptr<base::TaskRunner> GetTaskRunner() {
 424     return fetcher_.GetTaskRunner();
 425   }
 426
 427   scoped_ptr<URLRequestContext> context_;
 428   MockDhcpProxyScriptFetcherWin fetcher_;
 429   bool finished_;
 430   int result_;
 431   base::string16 pac_text_;
 432 };
 433
 434 // We separate out each test's logic so that we can easily implement
 435 // the ReuseFetcher test at the bottom.
 436 void TestNormalCaseURLConfiguredOneAdapter(FetcherClient* client) {
 437   TestURLRequestContext context;
 438   scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
 439       new DummyDhcpProxyScriptAdapterFetcher(&context,
 440                                              client->GetTaskRunner()));
 441   adapter_fetcher->Configure(true, OK, L"bingo", 1);
 442   client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
 443   client->RunTest();
 444   client->RunMessageLoopUntilComplete();
 445   ASSERT_EQ(OK, client->result_);
 446   ASSERT_EQ(L"bingo", client->pac_text_);
 447 }
 448
 449 TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredOneAdapter) {
 450   FetcherClient client;
 451   TestNormalCaseURLConfiguredOneAdapter(&client);
 452 }
 453
 454 void TestNormalCaseURLConfiguredMultipleAdapters(FetcherClient* client) {
 455   client->fetcher_.ConfigureAndPushBackAdapter(
 456       "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
 457       base::TimeDelta::FromMilliseconds(1));
 458   client->fetcher_.ConfigureAndPushBackAdapter(
 459       "second", true, OK, L"bingo", base::TimeDelta::FromMilliseconds(50));
 460   client->fetcher_.ConfigureAndPushBackAdapter(
 461       "third", true, OK, L"rocko", base::TimeDelta::FromMilliseconds(1));
 462   client->RunTest();
 463   client->RunMessageLoopUntilComplete();
 464   ASSERT_EQ(OK, client->result_);
 465   ASSERT_EQ(L"bingo", client->pac_text_);
 466 }
 467
 468 TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredMultipleAdapters) {
 469   FetcherClient client;
 470   TestNormalCaseURLConfiguredMultipleAdapters(&client);
 471 }
 472
 473 void TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout(
 474     FetcherClient* client) {
 475   client->fetcher_.ConfigureAndPushBackAdapter(
 476       "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
 477       base::TimeDelta::FromMilliseconds(1));
 478   // This will time out.
 479   client->fetcher_.ConfigureAndPushBackAdapter(
 480       "second", false, ERR_IO_PENDING, L"bingo",
 481       TestTimeouts::action_timeout());
 482   client->fetcher_.ConfigureAndPushBackAdapter(
 483       "third", true, OK, L"rocko", base::TimeDelta::FromMilliseconds(1));
 484   client->RunTest();
 485   client->RunMessageLoopUntilComplete();
 486   ASSERT_EQ(OK, client->result_);
 487   ASSERT_EQ(L"rocko", client->pac_text_);
 488 }
 489
 490 TEST(DhcpProxyScriptFetcherWin,
 491      NormalCaseURLConfiguredMultipleAdaptersWithTimeout) {
 492   FetcherClient client;
 493   TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout(&client);
 494 }
 495
 496 void TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout(
 497     FetcherClient* client) {
 498   client->fetcher_.ConfigureAndPushBackAdapter(
 499       "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
 500       base::TimeDelta::FromMilliseconds(1));
 501   // This will time out.
 502   client->fetcher_.ConfigureAndPushBackAdapter(
 503       "second", false, ERR_IO_PENDING, L"bingo",
 504       TestTimeouts::action_timeout());
 505   // This is the first non-ERR_PAC_NOT_IN_DHCP error and as such
 506   // should be chosen.
 507   client->fetcher_.ConfigureAndPushBackAdapter(
 508       "third", true, ERR_PAC_STATUS_NOT_OK, L"",
 509       base::TimeDelta::FromMilliseconds(1));
 510   client->fetcher_.ConfigureAndPushBackAdapter(
 511       "fourth", true, ERR_NOT_IMPLEMENTED, L"",
 512       base::TimeDelta::FromMilliseconds(1));
 513   client->RunTest();
 514   client->RunMessageLoopUntilComplete();
 515   ASSERT_EQ(ERR_PAC_STATUS_NOT_OK, client->result_);
 516   ASSERT_EQ(L"", client->pac_text_);
 517 }
 518
 519 TEST(DhcpProxyScriptFetcherWin,
 520      FailureCaseURLConfiguredMultipleAdaptersWithTimeout) {
 521   FetcherClient client;
 522   TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout(&client);
 523 }
 524
 525 void TestFailureCaseNoURLConfigured(FetcherClient* client) {
 526   client->fetcher_.ConfigureAndPushBackAdapter(
 527       "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
 528       base::TimeDelta::FromMilliseconds(1));
 529   // This will time out.
 530   client->fetcher_.ConfigureAndPushBackAdapter(
 531       "second", false, ERR_IO_PENDING, L"bingo",
 532       TestTimeouts::action_timeout());
 533   // This is the first non-ERR_PAC_NOT_IN_DHCP error and as such
 534   // should be chosen.
 535   client->fetcher_.ConfigureAndPushBackAdapter(
 536       "third", true, ERR_PAC_NOT_IN_DHCP, L"",
 537       base::TimeDelta::FromMilliseconds(1));
 538   client->RunTest();
 539   client->RunMessageLoopUntilComplete();
 540   ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, client->result_);
 541   ASSERT_EQ(L"", client->pac_text_);
 542 }
 543
 544 TEST(DhcpProxyScriptFetcherWin, FailureCaseNoURLConfigured) {
 545   FetcherClient client;
 546   TestFailureCaseNoURLConfigured(&client);
 547 }
 548
 549 void TestFailureCaseNoDhcpAdapters(FetcherClient* client) {
 550   client->RunTest();
 551   client->RunMessageLoopUntilComplete();
 552   ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, client->result_);
 553   ASSERT_EQ(L"", client->pac_text_);
 554   ASSERT_EQ(0, client->fetcher_.num_fetchers_created_);
 555 }
 556
 557 TEST(DhcpProxyScriptFetcherWin, FailureCaseNoDhcpAdapters) {
 558   FetcherClient client;
 559   TestFailureCaseNoDhcpAdapters(&client);
 560 }
 561
 562 void TestShortCircuitLessPreferredAdapters(FetcherClient* client) {
 563   // Here we have a bunch of adapters; the first reports no PAC in DHCP,
 564   // the second responds quickly with a PAC file, the rest take a long
 565   // time.  Verify that we complete quickly and do not wait for the slow
 566   // adapters, i.e. we finish before timeout.
 567   client->fetcher_.ConfigureAndPushBackAdapter(
 568       "1", true, ERR_PAC_NOT_IN_DHCP, L"",
 569       base::TimeDelta::FromMilliseconds(1));
 570   client->fetcher_.ConfigureAndPushBackAdapter(
 571       "2", true, OK, L"bingo",
 572       base::TimeDelta::FromMilliseconds(1));
 573   client->fetcher_.ConfigureAndPushBackAdapter(
 574       "3", true, OK, L"wrongo", TestTimeouts::action_max_timeout());
 575
 576   // Increase the timeout to ensure the short circuit mechanism has
 577   // time to kick in before the timeout waiting for more adapters kicks in.
 578   client->fetcher_.max_wait_ = TestTimeouts::action_timeout();
 579
 580   base::ElapsedTimer timer;
 581   client->RunTest();
 582   client->RunMessageLoopUntilComplete();
 583   ASSERT_TRUE(client->fetcher_.HasPendingFetchers());
 584   // Assert that the time passed is definitely less than the wait timer
 585   // timeout, to get a second signal that it was the shortcut mechanism
 586   // (in OnFetcherDone) that kicked in, and not the timeout waiting for
 587   // more adapters.
 588   ASSERT_GT(client->fetcher_.max_wait_ - (client->fetcher_.max_wait_ / 10),
 589             timer.Elapsed());
 590 }
 591
 592 TEST(DhcpProxyScriptFetcherWin, ShortCircuitLessPreferredAdapters) {
 593   FetcherClient client;
 594   TestShortCircuitLessPreferredAdapters(&client);
 595 }
 596
 597 void TestImmediateCancel(FetcherClient* client) {
 598   TestURLRequestContext context;
 599   scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
 600       new DummyDhcpProxyScriptAdapterFetcher(&context,
 601                                              client->GetTaskRunner()));
 602   adapter_fetcher->Configure(true, OK, L"bingo", 1);
 603   client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
 604   client->RunTest();
 605   client->fetcher_.Cancel();
 606   client->RunMessageLoopUntilWorkerDone();
 607   ASSERT_EQ(0, client->fetcher_.num_fetchers_created_);
 608 }
 609
 610 // Regression test to check that when we cancel immediately, no
 611 // adapter fetchers get created.
 612 TEST(DhcpProxyScriptFetcherWin, ImmediateCancel) {
 613   FetcherClient client;
 614   TestImmediateCancel(&client);
 615 }
 616
 617 TEST(DhcpProxyScriptFetcherWin, ReuseFetcher) {
 618   FetcherClient client;
 619
 620   // The ProxyScriptFetcher interface stipulates that only a single
 621   // |Fetch()| may be in flight at once, but allows reuse, so test
 622   // that the state transitions correctly from done to start in all
 623   // cases we're testing.
 624
 625   typedef void (*FetcherClientTestFunction)(FetcherClient*);
 626   typedef std::vector<FetcherClientTestFunction> TestVector;
 627   TestVector test_functions;
 628   test_functions.push_back(TestNormalCaseURLConfiguredOneAdapter);
 629   test_functions.push_back(TestNormalCaseURLConfiguredMultipleAdapters);
 630   test_functions.push_back(
 631       TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout);
 632   test_functions.push_back(
 633       TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout);
 634   test_functions.push_back(TestFailureCaseNoURLConfigured);
 635   test_functions.push_back(TestFailureCaseNoDhcpAdapters);
 636   test_functions.push_back(TestShortCircuitLessPreferredAdapters);
 637   test_functions.push_back(TestImmediateCancel);
 638
 639   std::random_shuffle(test_functions.begin(),
 640                       test_functions.end(),
 641                       base::RandGenerator);
 642   for (TestVector::const_iterator it = test_functions.begin();
 643        it != test_functions.end();
 644        ++it) {
 645     (*it)(&client);
 646     client.ResetTestState();
 647   }
 648
 649   // Re-do the first test to make sure the last test that was run did
 650   // not leave things in a bad state.
 651   (*test_functions.begin())(&client);
 652 }
 653
 654 }  // namespace
 655
 656 }  // namespace net