network_portal_detector_impl_unittest.cc revision c2e0dbddbe15c98d52c4786dac06cb8952a8ae6d 
1// Copyright (c) 2013 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 "base/compiler_specific.h"
6#include "base/logging.h"
7#include "base/memory/scoped_ptr.h"
8#include "base/message_loop.h"
9#include "chrome/browser/captive_portal/captive_portal_detector.h"
10#include "chrome/browser/captive_portal/testing_utils.h"
11#include "chrome/browser/chromeos/cros/cros_library.h"
12#include "chrome/browser/chromeos/cros/network_library.h"
13#include "chrome/browser/chromeos/cros/network_library_impl_base.h"
14#include "chrome/browser/chromeos/net/network_portal_detector_impl.h"
15#include "chrome/test/base/testing_profile.h"
16#include "net/base/net_errors.h"
17#include "testing/gtest/include/gtest/gtest.h"
18
19namespace chromeos {
20
21class NetworkPortalDetectorImplTest
22    : public testing::Test,
23      public captive_portal::CaptivePortalDetectorTestBase {
24 public:
25  NetworkPortalDetectorImplTest() {}
26  virtual ~NetworkPortalDetectorImplTest() {}
27
28  virtual void SetUp() {
29    CrosLibrary::Initialize(true);
30    network_library_ = CrosLibrary::Get()->GetNetworkLibrary();
31    DCHECK(network_library_);
32
33    ethernet_network_ = network_library_->FindNetworkByPath("eth1");
34    DCHECK(ethernet_network_);
35
36    wifi1_network_ = network_library_->FindNetworkByPath("wifi1");
37    DCHECK(wifi1_network_);
38
39    wifi2_network_ = network_library_->FindNetworkByPath("wifi2");
40    DCHECK(wifi2_network_);
41
42    profile_.reset(new TestingProfile());
43    network_portal_detector_.reset(
44        new NetworkPortalDetectorImpl(profile_->GetRequestContext()));
45    network_portal_detector_->Init();
46    network_portal_detector_->Enable(false);
47
48    set_detector(network_portal_detector_->captive_portal_detector_.get());
49
50    // Prevents flakiness due to message loop delays.
51    set_time_ticks(base::TimeTicks::Now());
52  }
53
54  virtual void TearDown() {
55    network_portal_detector_->Shutdown();
56    CrosLibrary::Shutdown();
57  }
58
59  void CheckPortalState(NetworkPortalDetector::CaptivePortalStatus status,
60                        int response_code,
61                        const Network* network) {
62    NetworkPortalDetector::CaptivePortalState state =
63        network_portal_detector()->GetCaptivePortalState(network);
64    ASSERT_EQ(status, state.status);
65    ASSERT_EQ(response_code, state.response_code);
66  }
67
68  NetworkLibrary* network_library() { return network_library_; }
69  Network* ethernet_network() { return ethernet_network_; }
70  Network* wifi1_network() { return wifi1_network_; }
71  Network* wifi2_network() { return wifi2_network_; }
72
73  Profile* profile() { return profile_.get(); }
74
75  NetworkPortalDetectorImpl* network_portal_detector() {
76    return network_portal_detector_.get();
77  }
78
79  NetworkPortalDetectorImpl::State state() {
80    return network_portal_detector()->state();
81  }
82
83  void enable_lazy_detection() {
84    network_portal_detector()->EnableLazyDetection();
85  }
86
87  void disable_lazy_detection() {
88    network_portal_detector()->DisableLazyDetection();
89  }
90
91  void cancel_portal_detection() {
92    network_portal_detector()->CancelPortalDetection();
93  }
94
95  bool detection_timeout_is_cancelled() {
96    return
97        network_portal_detector()->DetectionTimeoutIsCancelledForTesting();
98  }
99
100  bool is_state_idle() {
101    return (NetworkPortalDetectorImpl::STATE_IDLE == state());
102  }
103
104  bool is_state_portal_detection_pending() {
105    return (NetworkPortalDetectorImpl::STATE_PORTAL_CHECK_PENDING == state());
106  }
107
108  bool is_state_checking_for_portal() {
109    return (NetworkPortalDetectorImpl::STATE_CHECKING_FOR_PORTAL == state());
110  }
111
112  void set_request_timeout(const base::TimeDelta& timeout) {
113    network_portal_detector()->set_request_timeout_for_testing(timeout);
114  }
115
116  const base::TimeDelta& next_attempt_delay() {
117    return network_portal_detector()->next_attempt_delay_for_testing();
118  }
119
120  int attempt_count() {
121    return network_portal_detector()->attempt_count_for_testing();
122  }
123
124  void set_min_time_between_attempts(const base::TimeDelta& delta) {
125    network_portal_detector()->set_min_time_between_attempts_for_testing(delta);
126  }
127
128  void set_lazy_check_interval(const base::TimeDelta& delta) {
129    network_portal_detector()->set_lazy_check_interval_for_testing(delta);
130  }
131
132  void set_time_ticks(const base::TimeTicks& time_ticks) {
133    network_portal_detector()->set_time_ticks_for_testing(time_ticks);
134  }
135
136  void SetBehindPortal(Network* network) {
137    Network::TestApi test_api(network);
138        test_api.SetBehindPortal();
139    static_cast<NetworkLibraryImplBase*>(
140        network_library())->CallConnectToNetwork(network);
141    MessageLoop::current()->RunUntilIdle();
142  }
143
144  void SetConnected(Network* network) {
145    Network::TestApi test_api(network);
146    test_api.SetConnected();
147    static_cast<NetworkLibraryImplBase*>(
148        network_library())->CallConnectToNetwork(network);
149    MessageLoop::current()->RunUntilIdle();
150  }
151
152 private:
153  NetworkLibrary* network_library_;
154
155  // Pointer to a fake ethernet network.
156  Network* ethernet_network_;
157
158  // Pointer to a fake wifi1 network.
159  Network* wifi1_network_;
160
161  // Pointer to a fake wifi2 network.
162  Network* wifi2_network_;
163
164  MessageLoop message_loop_;
165
166  scoped_ptr<TestingProfile> profile_;
167  scoped_ptr<NetworkPortalDetectorImpl> network_portal_detector_;
168};
169
170TEST_F(NetworkPortalDetectorImplTest, NoPortal) {
171  ASSERT_TRUE(is_state_idle());
172
173  SetConnected(wifi1_network());
174
175  ASSERT_TRUE(is_state_checking_for_portal());
176  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
177                   wifi1_network());
178
179  CompleteURLFetch(net::OK, 204, NULL);
180
181  ASSERT_TRUE(is_state_idle());
182  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
183                   wifi1_network());
184}
185
186TEST_F(NetworkPortalDetectorImplTest, Portal) {
187  ASSERT_TRUE(is_state_idle());
188
189  // Check HTTP 200 response code.
190  SetConnected(wifi1_network());
191  ASSERT_TRUE(is_state_checking_for_portal());
192
193  CompleteURLFetch(net::OK, 200, NULL);
194
195  ASSERT_TRUE(is_state_idle());
196  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
197                   wifi1_network());
198
199  // Check HTTP 301 response code.
200  SetConnected(wifi2_network());
201  ASSERT_TRUE(is_state_checking_for_portal());
202
203  CompleteURLFetch(net::OK, 301, NULL);
204
205  ASSERT_TRUE(is_state_idle());
206  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 301,
207                   wifi2_network());
208
209  // Check HTTP 302 response code.
210  SetConnected(ethernet_network());
211  ASSERT_TRUE(is_state_checking_for_portal());
212
213  CompleteURLFetch(net::OK, 302, NULL);
214
215  ASSERT_TRUE(is_state_idle());
216  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 302,
217                   ethernet_network());
218}
219
220TEST_F(NetworkPortalDetectorImplTest, TwoNetworks) {
221  ASSERT_TRUE(is_state_idle());
222
223  SetConnected(wifi1_network());
224  ASSERT_TRUE(is_state_checking_for_portal());
225
226  // wifi is in portal state.
227  CompleteURLFetch(net::OK, 200, NULL);
228  ASSERT_TRUE(is_state_idle());
229
230  SetConnected(ethernet_network());
231  ASSERT_TRUE(is_state_checking_for_portal());
232
233  // ethernet is in online state.
234  CompleteURLFetch(net::OK, 204, NULL);
235  ASSERT_TRUE(is_state_idle());
236  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
237                   ethernet_network());
238  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
239                   wifi1_network());
240}
241
242TEST_F(NetworkPortalDetectorImplTest, NetworkChanged) {
243  ASSERT_TRUE(is_state_idle());
244
245  SetConnected(wifi1_network());
246
247  // WiFi is in portal state.
248  fetcher()->set_response_code(200);
249  ASSERT_TRUE(is_state_checking_for_portal());
250
251  // Active network is changed during portal detection for wifi.
252  SetConnected(ethernet_network());
253
254  // Portal detection for wifi is cancelled, portal detection for
255  // ethernet is initiated.
256  ASSERT_TRUE(is_state_checking_for_portal());
257
258  // ethernet is in online state.
259  CompleteURLFetch(net::OK, 204, NULL);
260  ASSERT_TRUE(is_state_idle());
261  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
262                   ethernet_network());
263
264  // As active network was changed during portal detection for wifi
265  // network, it's state must be unknown.
266  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
267                   wifi1_network());
268}
269
270TEST_F(NetworkPortalDetectorImplTest, NetworkStateNotChanged) {
271  ASSERT_TRUE(is_state_idle());
272
273  SetConnected(wifi1_network());
274  ASSERT_TRUE(is_state_checking_for_portal());
275
276  CompleteURLFetch(net::OK, 204, NULL);
277
278  ASSERT_TRUE(is_state_idle());
279  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
280                   wifi1_network());
281
282  SetConnected(wifi1_network());
283  ASSERT_TRUE(is_state_idle());
284}
285
286TEST_F(NetworkPortalDetectorImplTest, NetworkStateChanged) {
287  // Test for Portal -> Online -> Portal network state transitions.
288  ASSERT_TRUE(is_state_idle());
289
290  SetBehindPortal(wifi1_network());
291  ASSERT_TRUE(is_state_checking_for_portal());
292
293  CompleteURLFetch(net::OK, 200, NULL);
294
295  ASSERT_TRUE(is_state_idle());
296  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
297                   wifi1_network());
298
299  SetConnected(wifi1_network());
300  ASSERT_TRUE(is_state_checking_for_portal());
301
302  CompleteURLFetch(net::OK, 204, NULL);
303
304  ASSERT_TRUE(is_state_idle());
305  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
306                   wifi1_network());
307
308  SetBehindPortal(wifi1_network());
309  ASSERT_TRUE(is_state_checking_for_portal());
310
311  CompleteURLFetch(net::OK, 200, NULL);
312
313  ASSERT_TRUE(is_state_idle());
314  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
315                   wifi1_network());
316}
317
318TEST_F(NetworkPortalDetectorImplTest, PortalDetectionTimeout) {
319  ASSERT_TRUE(is_state_idle());
320
321  // For instantaneous timeout.
322  set_request_timeout(base::TimeDelta::FromSeconds(0));
323
324  ASSERT_TRUE(is_state_idle());
325  ASSERT_EQ(0, attempt_count());
326
327  SetConnected(wifi1_network());
328  MessageLoop::current()->RunUntilIdle();
329
330  // First portal detection timeouts, next portal detection is
331  // scheduled.
332  ASSERT_TRUE(is_state_portal_detection_pending());
333  ASSERT_EQ(1, attempt_count());
334  ASSERT_EQ(base::TimeDelta::FromSeconds(3), next_attempt_delay());
335}
336
337TEST_F(NetworkPortalDetectorImplTest, PortalDetectionRetryAfter) {
338  ASSERT_TRUE(is_state_idle());
339
340  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 101\n\n";
341
342  ASSERT_TRUE(is_state_idle());
343  ASSERT_EQ(0, attempt_count());
344
345  SetConnected(wifi1_network());
346  CompleteURLFetch(net::OK, 503, retry_after);
347
348  // First portal detection completed, next portal detection is
349  // scheduled after 101 seconds.
350  ASSERT_TRUE(is_state_portal_detection_pending());
351  ASSERT_EQ(1, attempt_count());
352  ASSERT_EQ(base::TimeDelta::FromSeconds(101), next_attempt_delay());
353}
354
355TEST_F(NetworkPortalDetectorImplTest, PortalDetectorRetryAfterIsSmall) {
356  ASSERT_TRUE(is_state_idle());
357
358  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 1\n\n";
359
360  ASSERT_TRUE(is_state_idle());
361  ASSERT_EQ(0, attempt_count());
362
363  SetConnected(wifi1_network());
364  CompleteURLFetch(net::OK, 503, retry_after);
365
366  // First portal detection completed, next portal detection is
367  // scheduled after 3 seconds (due to minimum time between detection
368  // attemps).
369  ASSERT_TRUE(is_state_portal_detection_pending());
370  ASSERT_EQ(1, attempt_count());
371  ASSERT_EQ(base::TimeDelta::FromSeconds(3), next_attempt_delay());
372}
373
374TEST_F(NetworkPortalDetectorImplTest, FirstAttemptFailed) {
375  ASSERT_TRUE(is_state_idle());
376
377  set_min_time_between_attempts(base::TimeDelta());
378  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 0\n\n";
379
380  ASSERT_TRUE(is_state_idle());
381  ASSERT_EQ(0, attempt_count());
382
383  SetConnected(wifi1_network());
384
385  CompleteURLFetch(net::OK, 503, retry_after);
386  ASSERT_TRUE(is_state_portal_detection_pending());
387  ASSERT_EQ(1, attempt_count());
388  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
389
390  // To run CaptivePortalDetector::DetectCaptivePortal().
391  MessageLoop::current()->RunUntilIdle();
392
393  CompleteURLFetch(net::OK, 204, NULL);
394  ASSERT_TRUE(is_state_idle());
395  ASSERT_EQ(2, attempt_count());
396  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
397                   wifi1_network());
398}
399
400TEST_F(NetworkPortalDetectorImplTest, AllAttemptsFailed) {
401  ASSERT_TRUE(is_state_idle());
402
403  set_min_time_between_attempts(base::TimeDelta());
404  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 0\n\n";
405
406  ASSERT_TRUE(is_state_idle());
407  ASSERT_EQ(0, attempt_count());
408
409  SetConnected(wifi1_network());
410
411  CompleteURLFetch(net::OK, 503, retry_after);
412  ASSERT_TRUE(is_state_portal_detection_pending());
413  ASSERT_EQ(1, attempt_count());
414  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
415
416  // To run CaptivePortalDetector::DetectCaptivePortal().
417  MessageLoop::current()->RunUntilIdle();
418
419  CompleteURLFetch(net::OK, 503, retry_after);
420  ASSERT_TRUE(is_state_portal_detection_pending());
421  ASSERT_EQ(2, attempt_count());
422  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
423
424  // To run CaptivePortalDetector::DetectCaptivePortal().
425  MessageLoop::current()->RunUntilIdle();
426
427  CompleteURLFetch(net::OK, 503, retry_after);
428  ASSERT_TRUE(is_state_idle());
429  ASSERT_EQ(3, attempt_count());
430  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE, 503,
431                   wifi1_network());
432}
433
434TEST_F(NetworkPortalDetectorImplTest, ProxyAuthRequired) {
435  ASSERT_TRUE(is_state_idle());
436  set_min_time_between_attempts(base::TimeDelta());
437
438  SetConnected(wifi1_network());
439  CompleteURLFetch(net::OK, 407, NULL);
440  ASSERT_EQ(1, attempt_count());
441  ASSERT_TRUE(is_state_portal_detection_pending());
442  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
443                   wifi1_network());
444
445  // To run CaptivePortalDetector::DetectCaptivePortal().
446  MessageLoop::current()->RunUntilIdle();
447
448  CompleteURLFetch(net::OK, 407, NULL);
449  ASSERT_EQ(2, attempt_count());
450  ASSERT_TRUE(is_state_portal_detection_pending());
451  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
452                   wifi1_network());
453
454  // To run CaptivePortalDetector::DetectCaptivePortal().
455  MessageLoop::current()->RunUntilIdle();
456
457  CompleteURLFetch(net::OK, 407, NULL);
458  ASSERT_EQ(3, attempt_count());
459  ASSERT_TRUE(is_state_idle());
460  CheckPortalState(
461      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED, 407,
462      wifi1_network());
463}
464
465TEST_F(NetworkPortalDetectorImplTest, NoResponseButBehindPortal) {
466  ASSERT_TRUE(is_state_idle());
467  set_min_time_between_attempts(base::TimeDelta());
468
469  SetBehindPortal(wifi1_network());
470  ASSERT_TRUE(is_state_checking_for_portal());
471
472  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
473                   net::URLFetcher::RESPONSE_CODE_INVALID,
474                   NULL);
475  ASSERT_EQ(1, attempt_count());
476  ASSERT_TRUE(is_state_portal_detection_pending());
477
478  // To run CaptivePortalDetector::DetectCaptivePortal().
479  MessageLoop::current()->RunUntilIdle();
480
481  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
482                   net::URLFetcher::RESPONSE_CODE_INVALID,
483                   NULL);
484  ASSERT_EQ(2, attempt_count());
485  ASSERT_TRUE(is_state_portal_detection_pending());
486
487  // To run CaptivePortalDetector::DetectCaptivePortal().
488  MessageLoop::current()->RunUntilIdle();
489
490  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
491                   net::URLFetcher::RESPONSE_CODE_INVALID,
492                   NULL);
493  ASSERT_EQ(3, attempt_count());
494  ASSERT_TRUE(is_state_idle());
495
496  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL,
497                   net::URLFetcher::RESPONSE_CODE_INVALID,
498                   wifi1_network());
499}
500
501TEST_F(NetworkPortalDetectorImplTest, LazyDetectionForOnlineNetwork) {
502  ASSERT_TRUE(is_state_idle());
503  set_min_time_between_attempts(base::TimeDelta());
504  set_lazy_check_interval(base::TimeDelta());
505
506  SetConnected(wifi1_network());
507  enable_lazy_detection();
508  CompleteURLFetch(net::OK, 204, NULL);
509
510  ASSERT_EQ(1, attempt_count());
511  ASSERT_TRUE(is_state_portal_detection_pending());
512  CheckPortalState(
513      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
514      wifi1_network());
515
516  // To run CaptivePortalDetector::DetectCaptivePortal().
517  MessageLoop::current()->RunUntilIdle();
518
519  CompleteURLFetch(net::OK, 204, NULL);
520
521  ASSERT_EQ(2, attempt_count());
522  ASSERT_TRUE(is_state_portal_detection_pending());
523  CheckPortalState(
524      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
525      wifi1_network());
526
527  // To run CaptivePortalDetector::DetectCaptivePortal().
528  MessageLoop::current()->RunUntilIdle();
529
530  disable_lazy_detection();
531
532  // One more detection result, because DizableLazyDetection() doesn't
533  // cancel last detection request.
534  CompleteURLFetch(net::OK, 204, NULL);
535  ASSERT_EQ(3, attempt_count());
536  ASSERT_TRUE(is_state_idle());
537  CheckPortalState(
538      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
539      wifi1_network());
540}
541
542TEST_F(NetworkPortalDetectorImplTest, LazyDetectionForPortalNetwork) {
543  ASSERT_TRUE(is_state_idle());
544  set_min_time_between_attempts(base::TimeDelta());
545  set_lazy_check_interval(base::TimeDelta());
546
547  SetConnected(wifi1_network());
548  enable_lazy_detection();
549
550  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
551                   net::URLFetcher::RESPONSE_CODE_INVALID,
552                   NULL);
553  ASSERT_EQ(1, attempt_count());
554  ASSERT_TRUE(is_state_portal_detection_pending());
555  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
556                   wifi1_network());
557
558  // To run CaptivePortalDetector::DetectCaptivePortal().
559  MessageLoop::current()->RunUntilIdle();
560
561  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
562                   net::URLFetcher::RESPONSE_CODE_INVALID,
563                   NULL);
564  ASSERT_EQ(2, attempt_count());
565  ASSERT_TRUE(is_state_portal_detection_pending());
566  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
567                   wifi1_network());
568
569  // To run CaptivePortalDetector::DetectCaptivePortal().
570  MessageLoop::current()->RunUntilIdle();
571
572  CompleteURLFetch(net::OK, 200, NULL);
573  ASSERT_EQ(3, attempt_count());
574  ASSERT_TRUE(is_state_portal_detection_pending());
575  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
576                   wifi1_network());
577
578  // To run CaptivePortalDetector::DetectCaptivePortal().
579  MessageLoop::current()->RunUntilIdle();
580
581  disable_lazy_detection();
582
583  // One more detection result, because DizableLazyDetection() doesn't
584  // cancel last detection request.
585  CompleteURLFetch(net::OK, 200, NULL);
586  ASSERT_EQ(3, attempt_count());
587  ASSERT_TRUE(is_state_idle());
588  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
589                   wifi1_network());
590}
591
592TEST_F(NetworkPortalDetectorImplTest, DetectionTimeoutIsCancelled) {
593  ASSERT_TRUE(is_state_idle());
594  set_min_time_between_attempts(base::TimeDelta());
595
596  SetConnected(wifi1_network());
597  ASSERT_TRUE(is_state_checking_for_portal());
598  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
599                   wifi1_network());
600
601  cancel_portal_detection();
602
603  ASSERT_TRUE(is_state_idle());
604  ASSERT_TRUE(detection_timeout_is_cancelled());
605  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
606                   wifi1_network());
607}
608
609}  // namespace chromeos
610