portal_detector_unittest.cc - aosp/platform/system/connectivity/shill - Git at Google

 //
 // Copyright (C) 2012 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //

 #include "shill/portal_detector.h"

 #include <memory>
 #include <string>
 #include <vector>

 #include <base/bind.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "shill/connectivity_trial.h"
 #include "shill/mock_connection.h"
 #include "shill/mock_connectivity_trial.h"
 #include "shill/mock_control.h"
 #include "shill/mock_device_info.h"
 #include "shill/mock_event_dispatcher.h"
 #include "shill/net/mock_time.h"

 using base::Bind;
 using base::Callback;
 using base::Unretained;
 using std::string;
 using std::vector;
 using testing::_;
 using testing::InSequence;
 using testing::Mock;
 using testing::NiceMock;
 using testing::Return;
 using testing::ReturnRef;
 using testing::StrictMock;
 using testing::Test;

 namespace shill {

 namespace {
 const char kBadURL[] = "badurl";
 const char kInterfaceName[] = "int0";
 const char kURL[] = "http://www.chromium.org";
 const char kDNSServer0[] = "8.8.8.8";
 const char kDNSServer1[] = "8.8.4.4";
 const char* const kDNSServers[] = {kDNSServer0, kDNSServer1};
 }  // namespace

 MATCHER_P(IsResult, result, "") {
   return (result.trial_result.phase == arg.trial_result.phase &&
           result.trial_result.status == arg.trial_result.status &&
           result.final == arg.final);
 }


 class PortalDetectorTest : public Test {
  public:
   PortalDetectorTest()
       : device_info_(
             new NiceMock<MockDeviceInfo>(&control_, nullptr, nullptr, nullptr)),
         connection_(new StrictMock<MockConnection>(device_info_.get())),
         portal_detector_(
             new PortalDetector(connection_.get(), &dispatcher_,
                                callback_target_.result_callback())),
         connectivity_trial_(new StrictMock<MockConnectivityTrial>(
             connection_, PortalDetector::kRequestTimeoutSeconds)),
         interface_name_(kInterfaceName),
         dns_servers_(kDNSServers, kDNSServers + 2) {
     current_time_.tv_sec = current_time_.tv_usec = 0;
   }

   void SetUp() override {
     EXPECT_CALL(*connection_.get(), IsIPv6())
         .WillRepeatedly(Return(false));
     EXPECT_CALL(*connection_.get(), interface_name())
         .WillRepeatedly(ReturnRef(interface_name_));
     portal_detector_->time_ = &time_;
     EXPECT_CALL(time_, GetTimeMonotonic(_))
         .WillRepeatedly(Invoke(this, &PortalDetectorTest::GetTimeMonotonic));
     EXPECT_CALL(*connection_.get(), dns_servers())
         .WillRepeatedly(ReturnRef(dns_servers_));
     portal_detector_->connectivity_trial_
         .reset(connectivity_trial_);  // Passes ownership
     EXPECT_TRUE(portal_detector()->connectivity_trial_.get());
   }

   void TearDown() override {
     if (portal_detector()->connectivity_trial_.get()) {
       EXPECT_CALL(*connectivity_trial(), Stop());

       // Delete the portal detector while expectations still exist.
       portal_detector_.reset();
     }
   }

  protected:
   static const int kNumAttempts;

   class CallbackTarget {
    public:
     CallbackTarget()
         : result_callback_(Bind(&CallbackTarget::ResultCallback,
                                 Unretained(this))) {
     }

     MOCK_METHOD1(ResultCallback, void(const PortalDetector::Result& result));
     Callback<void(const PortalDetector::Result&)>& result_callback() {
       return result_callback_;
     }

    private:
     Callback<void(const PortalDetector::Result&)> result_callback_;
   };

   bool StartPortalRequest(const string& url_string) {
     bool ret = portal_detector_->Start(url_string);
     return ret;
   }

   PortalDetector* portal_detector() { return portal_detector_.get(); }
   MockConnectivityTrial* connectivity_trial() { return connectivity_trial_; }
   MockEventDispatcher& dispatcher() { return dispatcher_; }
   CallbackTarget& callback_target() { return callback_target_; }

   void ExpectReset() {
     EXPECT_FALSE(portal_detector_->attempt_count_);
     EXPECT_FALSE(portal_detector_->failures_in_content_phase_);
     EXPECT_TRUE(callback_target_.result_callback().
                 Equals(portal_detector_->portal_result_callback_));
   }

   void ExpectAttemptRetry(const PortalDetector::Result& result) {
     EXPECT_CALL(callback_target(),
                 ResultCallback(IsResult(result)));
     EXPECT_CALL(*connectivity_trial(),
                 Retry(PortalDetector::kMinTimeBetweenAttemptsSeconds * 1000));
   }

   void AdvanceTime(int milliseconds) {
     struct timeval tv = { milliseconds / 1000, (milliseconds % 1000) * 1000 };
     timeradd(&current_time_, &tv, &current_time_);
   }

   void StartAttempt() {
     EXPECT_CALL(*connectivity_trial(), Start(_, _)).WillOnce(Return(true));

     EXPECT_TRUE(StartPortalRequest(kURL));
   }

  private:
   int GetTimeMonotonic(struct timeval* tv) {
     *tv = current_time_;
     return 0;
   }

   StrictMock<MockEventDispatcher> dispatcher_;
   MockControl control_;
   std::unique_ptr<MockDeviceInfo> device_info_;
   scoped_refptr<MockConnection> connection_;
   CallbackTarget callback_target_;
   std::unique_ptr<PortalDetector> portal_detector_;
   MockConnectivityTrial* connectivity_trial_;
   StrictMock<MockTime> time_;
   struct timeval current_time_;
   const string interface_name_;
   vector<string> dns_servers_;
 };

 // static
 const int PortalDetectorTest::kNumAttempts = 0;

 TEST_F(PortalDetectorTest, Constructor) {
   ExpectReset();
 }

 TEST_F(PortalDetectorTest, InvalidURL) {
   EXPECT_CALL(*connectivity_trial(), Start(_, _)).WillOnce(Return(false));
   EXPECT_FALSE(portal_detector()->Start(kBadURL));
   ExpectReset();
 }

 TEST_F(PortalDetectorTest, StartAttemptFailed) {
   EXPECT_CALL(*connectivity_trial(), Start(kURL, 0)).WillOnce(Return(true));
   EXPECT_TRUE(StartPortalRequest(kURL));

   // Expect that the request will be started -- return failure.
   ConnectivityTrial::Result errorResult =
       ConnectivityTrial::GetPortalResultForRequestResult(
           HttpRequest::kResultConnectionFailure);

   // Expect a non-final failure to be relayed to the caller.
   ExpectAttemptRetry(
       PortalDetector::Result(
           ConnectivityTrial::Result(
               ConnectivityTrial::kPhaseConnection,
               ConnectivityTrial::kStatusFailure),
           kNumAttempts,
           false));

   portal_detector()->CompleteAttempt(errorResult);
 }

 TEST_F(PortalDetectorTest, IsInProgress) {
   EXPECT_FALSE(portal_detector()->IsInProgress());
   // Starting the attempt immediately should result with IsInProgress returning
   // true
   EXPECT_CALL(*connectivity_trial(), Start(_, _))
       .Times(2).WillRepeatedly(Return(true));
   EXPECT_TRUE(StartPortalRequest(kURL));
   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
   EXPECT_TRUE(portal_detector()->IsInProgress());

   // Starting the attempt with a delay should result with IsInProgress returning
   // false
   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(false));
   portal_detector()->StartAfterDelay(kURL, 2);
   EXPECT_FALSE(portal_detector()->IsInProgress());

   // Advance time, IsInProgress should now be true
   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
   AdvanceTime(2000);
   EXPECT_TRUE(portal_detector()->IsInProgress());

   // Times beyond the start time before the attempt finishes should also return
   // true
   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
   AdvanceTime(1000);
   EXPECT_TRUE(portal_detector()->IsInProgress());
 }

 TEST_F(PortalDetectorTest, AdjustStartDelayImmediate) {
   EXPECT_CALL(*connectivity_trial(), Start(kURL, 0)).WillOnce(Return(true));
   EXPECT_TRUE(StartPortalRequest(kURL));

   // A second attempt should be delayed by kMinTimeBetweenAttemptsSeconds.
   EXPECT_TRUE(portal_detector()->AdjustStartDelay(0)
               == PortalDetector::kMinTimeBetweenAttemptsSeconds);
 }

 TEST_F(PortalDetectorTest, AdjustStartDelayAfterDelay) {
   const int kDelaySeconds = 123;
   // The first attempt should be delayed by kDelaySeconds.
   EXPECT_CALL(*connectivity_trial(), Start(kURL, kDelaySeconds * 1000))
       .WillOnce(Return(true));

   portal_detector()->StartAfterDelay(kURL, kDelaySeconds);

   AdvanceTime(kDelaySeconds * 1000);

   // A second attempt should be delayed by kMinTimeBetweenAttemptsSeconds.
   EXPECT_TRUE(portal_detector()->AdjustStartDelay(0)
               == PortalDetector::kMinTimeBetweenAttemptsSeconds);
 }

 TEST_F(PortalDetectorTest, AttemptCount) {
   EXPECT_FALSE(portal_detector()->IsInProgress());
   // Expect the PortalDetector to immediately post a task for the each attempt.
   EXPECT_CALL(*connectivity_trial(), Start(_, _))
       .Times(2).WillRepeatedly(Return(true));
   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(false));
   portal_detector()->StartAfterDelay(kURL, 2);

   EXPECT_FALSE(portal_detector()->IsInProgress());

   // Expect that the request will be started -- return failure.
   EXPECT_CALL(*connectivity_trial(), Retry(0))
       .Times(PortalDetector::kMaxRequestAttempts - 1);

   {
     InSequence s;

     // Expect non-final failures for all attempts but the last.
     EXPECT_CALL(callback_target(),
                 ResultCallback(IsResult(
                     PortalDetector::Result(
                         ConnectivityTrial::Result(
                             ConnectivityTrial::kPhaseDNS,
                             ConnectivityTrial::kStatusFailure),
                         kNumAttempts,
                         false))))
         .Times(PortalDetector::kMaxRequestAttempts - 1);

     // Expect a single final failure.
     EXPECT_CALL(callback_target(),
                 ResultCallback(IsResult(
                     PortalDetector::Result(
                         ConnectivityTrial::Result(
                             ConnectivityTrial::kPhaseDNS,
                             ConnectivityTrial::kStatusFailure),
                         kNumAttempts,
                         true))))
         .Times(1);
   }

   // Expect the PortalDetector to stop the ConnectivityTrial after
   // the final attempt.
   EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);

   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
   portal_detector()->Start(kURL);
   for (int i = 0; i < PortalDetector::kMaxRequestAttempts; i++) {
     EXPECT_TRUE(portal_detector()->IsInProgress());
     AdvanceTime(PortalDetector::kMinTimeBetweenAttemptsSeconds * 1000);
     ConnectivityTrial::Result r =
         ConnectivityTrial::GetPortalResultForRequestResult(
             HttpRequest::kResultDNSFailure);
     portal_detector()->CompleteAttempt(r);
   }

   EXPECT_FALSE(portal_detector()->IsInProgress());
   ExpectReset();
 }

 // Exactly like AttemptCount, except that the termination conditions are
 // different because we're triggering a different sort of error.
 TEST_F(PortalDetectorTest, ReadBadHeadersRetry) {
   EXPECT_FALSE(portal_detector()->IsInProgress());
   // Expect the PortalDetector to immediately post a task for the each attempt.
   EXPECT_CALL(*connectivity_trial(), Start(_, 0))
       .Times(2).WillRepeatedly(Return(true));

   EXPECT_TRUE(StartPortalRequest(kURL));

   // Expect that the request will be started -- return failure.
   EXPECT_CALL(*connectivity_trial(), Retry(0))
       .Times(PortalDetector::kMaxFailuresInContentPhase - 1);
   {
     InSequence s;

     // Expect non-final failures for all attempts but the last.
     EXPECT_CALL(callback_target(),
                 ResultCallback(IsResult(
                     PortalDetector::Result(
                         ConnectivityTrial::Result(
                             ConnectivityTrial::kPhaseContent,
                             ConnectivityTrial::kStatusFailure),
                         kNumAttempts,
                         false))))
         .Times(PortalDetector::kMaxFailuresInContentPhase - 1);

     // Expect a single final failure.
     EXPECT_CALL(callback_target(),
                 ResultCallback(IsResult(
                     PortalDetector::Result(
                         ConnectivityTrial::Result(
                             ConnectivityTrial::kPhaseContent,
                             ConnectivityTrial::kStatusFailure),
                         kNumAttempts,
                         true))))
         .Times(1);
   }

   // Expect the PortalDetector to stop the current request each time, plus
   // an extra time in PortalDetector::Stop().
   EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);

   EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
   portal_detector()->Start(kURL);
   for (int i = 0; i < PortalDetector::kMaxFailuresInContentPhase; i++) {
     EXPECT_TRUE(portal_detector()->IsInProgress());
     AdvanceTime(PortalDetector::kMinTimeBetweenAttemptsSeconds * 1000);
     ConnectivityTrial::Result r =
         ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
                                   ConnectivityTrial::kStatusFailure);
     portal_detector()->CompleteAttempt(r);
   }

   EXPECT_FALSE(portal_detector()->IsInProgress());
 }

 TEST_F(PortalDetectorTest, ReadBadHeader) {
   StartAttempt();

   ExpectAttemptRetry(
       PortalDetector::Result(
           ConnectivityTrial::Result(
               ConnectivityTrial::kPhaseContent,
               ConnectivityTrial::kStatusFailure),
           kNumAttempts,
           false));

   ConnectivityTrial::Result r =
       ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
                                 ConnectivityTrial::kStatusFailure);
   portal_detector()->CompleteAttempt(r);
 }

 TEST_F(PortalDetectorTest, RequestTimeout) {
   StartAttempt();
   ExpectAttemptRetry(
       PortalDetector::Result(
           ConnectivityTrial::Result(
               ConnectivityTrial::kPhaseUnknown,
               ConnectivityTrial::kStatusTimeout),
           kNumAttempts,
           false));

   ConnectivityTrial::Result r =
       ConnectivityTrial::Result(ConnectivityTrial::kPhaseUnknown,
                                 ConnectivityTrial::kStatusTimeout);
   portal_detector()->CompleteAttempt(r);
 }

 TEST_F(PortalDetectorTest, ReadPartialHeaderTimeout) {
   StartAttempt();

   ExpectAttemptRetry(
       PortalDetector::Result(
           ConnectivityTrial::Result(
               ConnectivityTrial::kPhaseContent,
               ConnectivityTrial::kStatusTimeout),
           kNumAttempts,
           false));

   ConnectivityTrial::Result r =
       ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
                                 ConnectivityTrial::kStatusTimeout);
   portal_detector()->CompleteAttempt(r);
 }

 TEST_F(PortalDetectorTest, ReadCompleteHeader) {
   StartAttempt();

   EXPECT_CALL(callback_target(),
               ResultCallback(IsResult(
                   PortalDetector::Result(
                       ConnectivityTrial::Result(
                           ConnectivityTrial::kPhaseContent,
                           ConnectivityTrial::kStatusSuccess),
                       kNumAttempts,
                       true))));

   EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);
   ConnectivityTrial::Result r =
       ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
                                 ConnectivityTrial::kStatusSuccess);
   portal_detector()->CompleteAttempt(r);
 }

 TEST_F(PortalDetectorTest, ReadMatchingHeader) {
   StartAttempt();

   EXPECT_CALL(callback_target(),
               ResultCallback(IsResult(
                   PortalDetector::Result(
                       ConnectivityTrial::Result(
                           ConnectivityTrial::kPhaseContent,
                           ConnectivityTrial::kStatusSuccess),
                       kNumAttempts,
                       true))));
   EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);
   ConnectivityTrial::Result r =
       ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
                                 ConnectivityTrial::kStatusSuccess);
   portal_detector()->CompleteAttempt(r);
 }

 }  // namespace shill
	//
	// Copyright (C) 2012 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//

	#include "shill/portal_detector.h"

	#include <memory>
	#include <string>
	#include <vector>

	#include <base/bind.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "shill/connectivity_trial.h"
	#include "shill/mock_connection.h"
	#include "shill/mock_connectivity_trial.h"
	#include "shill/mock_control.h"
	#include "shill/mock_device_info.h"
	#include "shill/mock_event_dispatcher.h"
	#include "shill/net/mock_time.h"

	using base::Bind;
	using base::Callback;
	using base::Unretained;
	using std::string;
	using std::vector;
	using testing::_;
	using testing::InSequence;
	using testing::Mock;
	using testing::NiceMock;
	using testing::Return;
	using testing::ReturnRef;
	using testing::StrictMock;
	using testing::Test;

	namespace shill {

	namespace {
	const char kBadURL[] = "badurl";
	const char kInterfaceName[] = "int0";
	const char kURL[] = "http://www.chromium.org";
	const char kDNSServer0[] = "8.8.8.8";
	const char kDNSServer1[] = "8.8.4.4";
	const char* const kDNSServers[] = {kDNSServer0, kDNSServer1};
	} // namespace

	MATCHER_P(IsResult, result, "") {
	return (result.trial_result.phase == arg.trial_result.phase &&
	result.trial_result.status == arg.trial_result.status &&
	result.final == arg.final);
	}


	class PortalDetectorTest : public Test {
	public:
	PortalDetectorTest()
	: device_info_(
	new NiceMock<MockDeviceInfo>(&control_, nullptr, nullptr, nullptr)),
	connection_(new StrictMock<MockConnection>(device_info_.get())),
	portal_detector_(
	new PortalDetector(connection_.get(), &dispatcher_,
	callback_target_.result_callback())),
	connectivity_trial_(new StrictMock<MockConnectivityTrial>(
	connection_, PortalDetector::kRequestTimeoutSeconds)),
	interface_name_(kInterfaceName),
	dns_servers_(kDNSServers, kDNSServers + 2) {
	current_time_.tv_sec = current_time_.tv_usec = 0;
	}

	void SetUp() override {
	EXPECT_CALL(*connection_.get(), IsIPv6())
	.WillRepeatedly(Return(false));
	EXPECT_CALL(*connection_.get(), interface_name())
	.WillRepeatedly(ReturnRef(interface_name_));
	portal_detector_->time_ = &time_;
	EXPECT_CALL(time_, GetTimeMonotonic(_))
	.WillRepeatedly(Invoke(this, &PortalDetectorTest::GetTimeMonotonic));
	EXPECT_CALL(*connection_.get(), dns_servers())
	.WillRepeatedly(ReturnRef(dns_servers_));
	portal_detector_->connectivity_trial_
	.reset(connectivity_trial_); // Passes ownership
	EXPECT_TRUE(portal_detector()->connectivity_trial_.get());
	}

	void TearDown() override {
	if (portal_detector()->connectivity_trial_.get()) {
	EXPECT_CALL(*connectivity_trial(), Stop());

	// Delete the portal detector while expectations still exist.
	portal_detector_.reset();
	}
	}

	protected:
	static const int kNumAttempts;

	class CallbackTarget {
	public:
	CallbackTarget()
	: result_callback_(Bind(&CallbackTarget::ResultCallback,
	Unretained(this))) {
	}

	MOCK_METHOD1(ResultCallback, void(const PortalDetector::Result& result));
	Callback<void(const PortalDetector::Result&)>& result_callback() {
	return result_callback_;
	}

	private:
	Callback<void(const PortalDetector::Result&)> result_callback_;
	};

	bool StartPortalRequest(const string& url_string) {
	bool ret = portal_detector_->Start(url_string);
	return ret;
	}

	PortalDetector* portal_detector() { return portal_detector_.get(); }
	MockConnectivityTrial* connectivity_trial() { return connectivity_trial_; }
	MockEventDispatcher& dispatcher() { return dispatcher_; }
	CallbackTarget& callback_target() { return callback_target_; }

	void ExpectReset() {
	EXPECT_FALSE(portal_detector_->attempt_count_);
	EXPECT_FALSE(portal_detector_->failures_in_content_phase_);
	EXPECT_TRUE(callback_target_.result_callback().
	Equals(portal_detector_->portal_result_callback_));
	}

	void ExpectAttemptRetry(const PortalDetector::Result& result) {
	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(result)));
	EXPECT_CALL(*connectivity_trial(),
	Retry(PortalDetector::kMinTimeBetweenAttemptsSeconds * 1000));
	}

	void AdvanceTime(int milliseconds) {
	struct timeval tv = { milliseconds / 1000, (milliseconds % 1000) * 1000 };
	timeradd(&current_time_, &tv, &current_time_);
	}

	void StartAttempt() {
	EXPECT_CALL(*connectivity_trial(), Start(_, _)).WillOnce(Return(true));

	EXPECT_TRUE(StartPortalRequest(kURL));
	}

	private:
	int GetTimeMonotonic(struct timeval* tv) {
	*tv = current_time_;
	return 0;
	}

	StrictMock<MockEventDispatcher> dispatcher_;
	MockControl control_;
	std::unique_ptr<MockDeviceInfo> device_info_;
	scoped_refptr<MockConnection> connection_;
	CallbackTarget callback_target_;
	std::unique_ptr<PortalDetector> portal_detector_;
	MockConnectivityTrial* connectivity_trial_;
	StrictMock<MockTime> time_;
	struct timeval current_time_;
	const string interface_name_;
	vector<string> dns_servers_;
	};

	// static
	const int PortalDetectorTest::kNumAttempts = 0;

	TEST_F(PortalDetectorTest, Constructor) {
	ExpectReset();
	}

	TEST_F(PortalDetectorTest, InvalidURL) {
	EXPECT_CALL(*connectivity_trial(), Start(_, _)).WillOnce(Return(false));
	EXPECT_FALSE(portal_detector()->Start(kBadURL));
	ExpectReset();
	}

	TEST_F(PortalDetectorTest, StartAttemptFailed) {
	EXPECT_CALL(*connectivity_trial(), Start(kURL, 0)).WillOnce(Return(true));
	EXPECT_TRUE(StartPortalRequest(kURL));

	// Expect that the request will be started -- return failure.
	ConnectivityTrial::Result errorResult =
	ConnectivityTrial::GetPortalResultForRequestResult(
	HttpRequest::kResultConnectionFailure);

	// Expect a non-final failure to be relayed to the caller.
	ExpectAttemptRetry(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseConnection,
	ConnectivityTrial::kStatusFailure),
	kNumAttempts,
	false));

	portal_detector()->CompleteAttempt(errorResult);
	}

	TEST_F(PortalDetectorTest, IsInProgress) {
	EXPECT_FALSE(portal_detector()->IsInProgress());
	// Starting the attempt immediately should result with IsInProgress returning
	// true
	EXPECT_CALL(*connectivity_trial(), Start(_, _))
	.Times(2).WillRepeatedly(Return(true));
	EXPECT_TRUE(StartPortalRequest(kURL));
	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
	EXPECT_TRUE(portal_detector()->IsInProgress());

	// Starting the attempt with a delay should result with IsInProgress returning
	// false
	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(false));
	portal_detector()->StartAfterDelay(kURL, 2);
	EXPECT_FALSE(portal_detector()->IsInProgress());

	// Advance time, IsInProgress should now be true
	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
	AdvanceTime(2000);
	EXPECT_TRUE(portal_detector()->IsInProgress());

	// Times beyond the start time before the attempt finishes should also return
	// true
	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
	AdvanceTime(1000);
	EXPECT_TRUE(portal_detector()->IsInProgress());
	}

	TEST_F(PortalDetectorTest, AdjustStartDelayImmediate) {
	EXPECT_CALL(*connectivity_trial(), Start(kURL, 0)).WillOnce(Return(true));
	EXPECT_TRUE(StartPortalRequest(kURL));

	// A second attempt should be delayed by kMinTimeBetweenAttemptsSeconds.
	EXPECT_TRUE(portal_detector()->AdjustStartDelay(0)
	== PortalDetector::kMinTimeBetweenAttemptsSeconds);
	}

	TEST_F(PortalDetectorTest, AdjustStartDelayAfterDelay) {
	const int kDelaySeconds = 123;
	// The first attempt should be delayed by kDelaySeconds.
	EXPECT_CALL(connectivity_trial(), Start(kURL, kDelaySeconds 1000))
	.WillOnce(Return(true));

	portal_detector()->StartAfterDelay(kURL, kDelaySeconds);

	AdvanceTime(kDelaySeconds * 1000);

	// A second attempt should be delayed by kMinTimeBetweenAttemptsSeconds.
	EXPECT_TRUE(portal_detector()->AdjustStartDelay(0)
	== PortalDetector::kMinTimeBetweenAttemptsSeconds);
	}

	TEST_F(PortalDetectorTest, AttemptCount) {
	EXPECT_FALSE(portal_detector()->IsInProgress());
	// Expect the PortalDetector to immediately post a task for the each attempt.
	EXPECT_CALL(*connectivity_trial(), Start(_, _))
	.Times(2).WillRepeatedly(Return(true));
	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(false));
	portal_detector()->StartAfterDelay(kURL, 2);

	EXPECT_FALSE(portal_detector()->IsInProgress());

	// Expect that the request will be started -- return failure.
	EXPECT_CALL(*connectivity_trial(), Retry(0))
	.Times(PortalDetector::kMaxRequestAttempts - 1);

	{
	InSequence s;

	// Expect non-final failures for all attempts but the last.
	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseDNS,
	ConnectivityTrial::kStatusFailure),
	kNumAttempts,
	false))))
	.Times(PortalDetector::kMaxRequestAttempts - 1);

	// Expect a single final failure.
	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseDNS,
	ConnectivityTrial::kStatusFailure),
	kNumAttempts,
	true))))
	.Times(1);
	}

	// Expect the PortalDetector to stop the ConnectivityTrial after
	// the final attempt.
	EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);

	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
	portal_detector()->Start(kURL);
	for (int i = 0; i < PortalDetector::kMaxRequestAttempts; i++) {
	EXPECT_TRUE(portal_detector()->IsInProgress());
	AdvanceTime(PortalDetector::kMinTimeBetweenAttemptsSeconds * 1000);
	ConnectivityTrial::Result r =
	ConnectivityTrial::GetPortalResultForRequestResult(
	HttpRequest::kResultDNSFailure);
	portal_detector()->CompleteAttempt(r);
	}

	EXPECT_FALSE(portal_detector()->IsInProgress());
	ExpectReset();
	}

	// Exactly like AttemptCount, except that the termination conditions are
	// different because we're triggering a different sort of error.
	TEST_F(PortalDetectorTest, ReadBadHeadersRetry) {
	EXPECT_FALSE(portal_detector()->IsInProgress());
	// Expect the PortalDetector to immediately post a task for the each attempt.
	EXPECT_CALL(*connectivity_trial(), Start(_, 0))
	.Times(2).WillRepeatedly(Return(true));

	EXPECT_TRUE(StartPortalRequest(kURL));

	// Expect that the request will be started -- return failure.
	EXPECT_CALL(*connectivity_trial(), Retry(0))
	.Times(PortalDetector::kMaxFailuresInContentPhase - 1);
	{
	InSequence s;

	// Expect non-final failures for all attempts but the last.
	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusFailure),
	kNumAttempts,
	false))))
	.Times(PortalDetector::kMaxFailuresInContentPhase - 1);

	// Expect a single final failure.
	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusFailure),
	kNumAttempts,
	true))))
	.Times(1);
	}

	// Expect the PortalDetector to stop the current request each time, plus
	// an extra time in PortalDetector::Stop().
	EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);

	EXPECT_CALL(*connectivity_trial(), IsActive()).WillOnce(Return(true));
	portal_detector()->Start(kURL);
	for (int i = 0; i < PortalDetector::kMaxFailuresInContentPhase; i++) {
	EXPECT_TRUE(portal_detector()->IsInProgress());
	AdvanceTime(PortalDetector::kMinTimeBetweenAttemptsSeconds * 1000);
	ConnectivityTrial::Result r =
	ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusFailure);
	portal_detector()->CompleteAttempt(r);
	}

	EXPECT_FALSE(portal_detector()->IsInProgress());
	}

	TEST_F(PortalDetectorTest, ReadBadHeader) {
	StartAttempt();

	ExpectAttemptRetry(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusFailure),
	kNumAttempts,
	false));

	ConnectivityTrial::Result r =
	ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusFailure);
	portal_detector()->CompleteAttempt(r);
	}

	TEST_F(PortalDetectorTest, RequestTimeout) {
	StartAttempt();
	ExpectAttemptRetry(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseUnknown,
	ConnectivityTrial::kStatusTimeout),
	kNumAttempts,
	false));

	ConnectivityTrial::Result r =
	ConnectivityTrial::Result(ConnectivityTrial::kPhaseUnknown,
	ConnectivityTrial::kStatusTimeout);
	portal_detector()->CompleteAttempt(r);
	}

	TEST_F(PortalDetectorTest, ReadPartialHeaderTimeout) {
	StartAttempt();

	ExpectAttemptRetry(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusTimeout),
	kNumAttempts,
	false));

	ConnectivityTrial::Result r =
	ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusTimeout);
	portal_detector()->CompleteAttempt(r);
	}

	TEST_F(PortalDetectorTest, ReadCompleteHeader) {
	StartAttempt();

	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusSuccess),
	kNumAttempts,
	true))));

	EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);
	ConnectivityTrial::Result r =
	ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusSuccess);
	portal_detector()->CompleteAttempt(r);
	}

	TEST_F(PortalDetectorTest, ReadMatchingHeader) {
	StartAttempt();

	EXPECT_CALL(callback_target(),
	ResultCallback(IsResult(
	PortalDetector::Result(
	ConnectivityTrial::Result(
	ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusSuccess),
	kNumAttempts,
	true))));
	EXPECT_CALL(*connectivity_trial(), Stop()).Times(1);
	ConnectivityTrial::Result r =
	ConnectivityTrial::Result(ConnectivityTrial::kPhaseContent,
	ConnectivityTrial::kStatusSuccess);
	portal_detector()->CompleteAttempt(r);
	}

	} // namespace shill