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