// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "shill/link_monitor.h"

#include <net/if_arp.h>

#include <string>

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

#include "shill/arp_packet.h"
#include "shill/logging.h"
#include "shill/mock_arp_client.h"
#include "shill/mock_connection.h"
#include "shill/mock_control.h"
#include "shill/mock_device_info.h"
#include "shill/mock_event_dispatcher.h"
#include "shill/mock_log.h"
#include "shill/mock_metrics.h"
#include "shill/net/byte_string.h"
#include "shill/net/ip_address.h"
#include "shill/net/mock_sockets.h"
#include "shill/net/mock_time.h"

using base::Bind;
using base::Unretained;
using std::string;
using testing::_;
using testing::AnyNumber;
using testing::HasSubstr;
using testing::Invoke;
using testing::Mock;
using testing::NiceMock;
using testing::Return;
using testing::ReturnRef;
using testing::SetArgumentPointee;
using testing::StrictMock;
using testing::Test;

namespace shill {

namespace {
const char kInterfaceName[] = "int0";
const char kLocalIPAddress[] = "10.0.1.1";
const uint8_t kLocalMACAddress[] = { 0, 1, 2, 3, 4, 5 };
const char kRemoteIPAddress[] = "10.0.1.2";
const uint8_t kRemoteMACAddress[] = { 6, 7, 8, 9, 10, 11 };
const char kDBusPath[] = "/dbus/path";
}  // namespace


class LinkMonitorForTest : public LinkMonitor {
 public:
  LinkMonitorForTest(const ConnectionRefPtr &connection,
                     EventDispatcher *dispatcher,
                     Metrics *metrics,
                     DeviceInfo *device_info)
      : LinkMonitor(connection, dispatcher, metrics, device_info,
                    Bind(&LinkMonitorForTest::FailureCallbackHandler,
                         Unretained(this)),
                    Bind(&LinkMonitorForTest::GatewayChangeCallbackHandler,
                         Unretained(this))) {}

  virtual ~LinkMonitorForTest() {}

  MOCK_METHOD0(CreateClient, bool());

  // This does not override any methods in LinkMonitor, but is used here
  // in unit tests to support expectations when the LinkMonitor notifies
  // its client of a failure.
  MOCK_METHOD0(FailureCallbackHandler, void());

  // This does not override any methods in LinkMonitor, but is used here
  // in unit tests to support expectations when the LinkMonitor notifies
  // its client of a gateway mac address change.
  MOCK_METHOD0(GatewayChangeCallbackHandler, void());
};

MATCHER_P4(IsArpRequest, local_ip, remote_ip, local_mac, remote_mac, "") {
  if (local_ip.Equals(arg.local_ip_address()) &&
      remote_ip.Equals(arg.remote_ip_address()) &&
      local_mac.Equals(arg.local_mac_address()) &&
      remote_mac.Equals(arg.remote_mac_address()))
    return true;

  if (!local_ip.Equals(arg.local_ip_address())) {
    *result_listener << "Local IP '" << arg.local_ip_address().ToString()
                     << "' (wanted '" << local_ip.ToString() << "').";
  }

  if (!remote_ip.Equals(arg.remote_ip_address())) {
    *result_listener << "Remote IP '" << arg.remote_ip_address().ToString()
                     << "' (wanted '" << remote_ip.ToString() << "').";
  }

  if (!local_mac.Equals(arg.local_mac_address())) {
    *result_listener << "Local MAC '" << arg.local_mac_address().HexEncode()
                     << "' (wanted " << local_mac.HexEncode() << ")'.";
  }

  if (!remote_mac.Equals(arg.remote_mac_address())) {
    *result_listener << "Remote MAC '" << arg.remote_mac_address().HexEncode()
                     << "' (wanted " << remote_mac.HexEncode() << ")'.";
  }

  return false;
}

class LinkMonitorTest : public Test {
 public:
  LinkMonitorTest()
      : metrics_(&dispatcher_),
        device_info_(&control_, nullptr, nullptr, nullptr),
        connection_(new StrictMock<MockConnection>(&device_info_)),
        monitor_(connection_, &dispatcher_, &metrics_, &device_info_),
        client_(nullptr),
        next_client_(new StrictMock<MockArpClient>()),
        gateway_ip_(IPAddress::kFamilyIPv4),
        local_ip_(IPAddress::kFamilyIPv4),
        gateway_mac_(kRemoteMACAddress, arraysize(kRemoteMACAddress)),
        local_mac_(kLocalMACAddress, arraysize(kLocalMACAddress)),
        zero_mac_(arraysize(kLocalMACAddress)),
        link_scope_logging_was_enabled_(false),
        interface_name_(kInterfaceName) {}
  virtual ~LinkMonitorTest() {}

  virtual void SetUp() {
    link_scope_logging_was_enabled_ = SLOG_IS_ON(Link, 0);
    if (!link_scope_logging_was_enabled_) {
      ScopeLogger::GetInstance()->EnableScopesByName("link");
      ScopeLogger::GetInstance()->set_verbose_level(4);
    }
    monitor_.time_ = &time_;
    time_val_.tv_sec = 0;
    time_val_.tv_usec = 0;
    EXPECT_CALL(time_, GetTimeMonotonic(_))
        .WillRepeatedly(DoAll(SetArgumentPointee<0>(time_val_), Return(0)));
    EXPECT_TRUE(local_ip_.SetAddressFromString(kLocalIPAddress));
    EXPECT_CALL(*connection_, local()).WillRepeatedly(ReturnRef(local_ip_));
    EXPECT_TRUE(gateway_ip_.SetAddressFromString(kRemoteIPAddress));
    EXPECT_CALL(*connection_, gateway()).WillRepeatedly(ReturnRef(gateway_ip_));
    EXPECT_CALL(*connection_, technology())
        .WillRepeatedly(Return(Technology::kEthernet));
    EXPECT_CALL(*connection_, ipconfig_rpc_identifier())
        .WillRepeatedly(testing::ReturnPointee(&kDBusPath));
    EXPECT_CALL(*connection_, interface_name())
        .WillRepeatedly(ReturnRef(interface_name_));
  }

  virtual void TearDown() {
    if (!link_scope_logging_was_enabled_) {
      ScopeLogger::GetInstance()->EnableScopesByName("-link");
      ScopeLogger::GetInstance()->set_verbose_level(0);
    }
  }

  void AdvanceTime(int time_ms) {
    struct timeval adv_time = {
      static_cast<time_t>(time_ms/1000),
      static_cast<time_t>((time_ms % 1000) * 1000) };
    timeradd(&time_val_, &adv_time, &time_val_);
    EXPECT_CALL(time_, GetTimeMonotonic(_))
        .WillRepeatedly(DoAll(SetArgumentPointee<0>(time_val_), Return(0)));
  }

  bool CreateMockClient() {
    EXPECT_FALSE(monitor_.arp_client_.get());
    if (client_) {
      Mock::VerifyAndClearExpectations(client_);
    }
    client_ = next_client_;
    next_client_ = new StrictMock<MockArpClient>();
    monitor_.arp_client_.reset(client_);
    return true;
  }

  string HardwareAddressToString(const ByteString &address) {
    return LinkMonitor::HardwareAddressToString(address);
  }

 protected:
  void ExpectReset() {
    EXPECT_FALSE(monitor_.GetResponseTimeMilliseconds());
    EXPECT_FALSE(GetArpClient());
    EXPECT_TRUE(GetSendRequestCallback().IsCancelled());
    EXPECT_EQ(0, GetBroadcastFailureCount());
    EXPECT_EQ(0, GetUnicastFailureCount());
    EXPECT_EQ(0, GetBroadcastSuccessCount());
    EXPECT_EQ(0, GetUnicastSuccessCount());
    EXPECT_FALSE(IsUnicast());
    EXPECT_FALSE(GatewaySupportsUnicastArp());
  }
  const ArpClient *GetArpClient() { return monitor_.arp_client_.get(); }
  void TriggerRequestTimer() {
    GetSendRequestCallback().callback().Run();
  }
  const base::CancelableClosure &GetSendRequestCallback() {
    return monitor_.send_request_callback_;
  }
  int GetBroadcastFailureCount() {
    return monitor_.broadcast_failure_count_;
  }
  int GetUnicastFailureCount() {
    return monitor_.unicast_failure_count_;
  }
  int GetBroadcastSuccessCount() {
    return monitor_.broadcast_success_count_;
  }
  int GetUnicastSuccessCount() {
    return monitor_.unicast_success_count_;
  }
  bool IsUnicast() { return monitor_.is_unicast_; }
  bool GatewaySupportsUnicastArp() {
    return monitor_.gateway_supports_unicast_arp_;
  }
  void SetGatewaySupportsUnicastArp(bool gateway_supports_unicast_arp) {
    monitor_.gateway_supports_unicast_arp_ = gateway_supports_unicast_arp;
  }
  int GetCurrentTestPeriodMilliseconds() {
    return monitor_.test_period_milliseconds_;
  }
  int GetDefaultTestPeriodMilliseconds() {
    return LinkMonitor::kDefaultTestPeriodMilliseconds;
  }
  size_t GetFailureThreshold() {
    return LinkMonitor::kFailureThreshold;
  }
  size_t GetUnicastReplyReliabilityThreshold() {
    return LinkMonitor::kUnicastReplyReliabilityThreshold;
  }
  int GetFastTestPeriodMilliseconds() {
    return LinkMonitor::kFastTestPeriodMilliseconds;
  }
  int GetMaxResponseSampleFilterDepth() {
    return LinkMonitor::kMaxResponseSampleFilterDepth;
  }
  void ExpectTransmit(bool is_unicast, int transmit_period_milliseconds) {
    const ByteString &destination_mac = is_unicast ? gateway_mac_ : zero_mac_;
    if (monitor_.arp_client_.get()) {
      EXPECT_EQ(client_, monitor_.arp_client_.get());
      EXPECT_CALL(*client_, TransmitRequest(
          IsArpRequest(local_ip_, gateway_ip_, local_mac_, destination_mac)))
          .WillOnce(Return(true));
    } else {
      EXPECT_CALL(monitor_, CreateClient())
          .WillOnce(Invoke(this, &LinkMonitorTest::CreateMockClient));
      EXPECT_CALL(*next_client_, TransmitRequest(
          IsArpRequest(local_ip_, gateway_ip_, local_mac_, destination_mac)))
          .WillOnce(Return(true));
    }
    EXPECT_CALL(dispatcher_,
                PostDelayedTask(_, transmit_period_milliseconds));
  }
  void SendNextRequest() {
    EXPECT_CALL(monitor_, CreateClient())
        .WillOnce(Invoke(this, &LinkMonitorTest::CreateMockClient));
    EXPECT_CALL(*next_client_, TransmitRequest(_)).WillOnce(Return(true));
    EXPECT_CALL(dispatcher_,
                PostDelayedTask(_, GetCurrentTestPeriodMilliseconds()));
    TriggerRequestTimer();
  }
  void ExpectNoTransmit() {
    MockArpClient *client =
      monitor_.arp_client_.get() ? client_ : next_client_;
    EXPECT_CALL(*client, TransmitRequest(_)).Times(0);
  }
  void ExpectRestart(int transmit_period_milliseconds) {
    EXPECT_CALL(device_info_, GetMACAddress(0, _))
        .WillOnce(DoAll(SetArgumentPointee<1>(local_mac_), Return(true)));
    // Can't just use ExpectTransmit, because that depends on state
    // that changes during Stop.
    EXPECT_CALL(monitor_, CreateClient())
        .WillOnce(Invoke(this, &LinkMonitorTest::CreateMockClient));
    EXPECT_CALL(*next_client_, TransmitRequest(
        IsArpRequest(local_ip_, gateway_ip_, local_mac_, zero_mac_)))
        .WillOnce(Return(true));
    EXPECT_CALL(dispatcher_,
                PostDelayedTask(_, transmit_period_milliseconds));
  }
  void StartMonitor() {
    EXPECT_CALL(device_info_, GetMACAddress(0, _))
        .WillOnce(DoAll(SetArgumentPointee<1>(local_mac_), Return(true)));
    ExpectTransmit(false, GetDefaultTestPeriodMilliseconds());
    EXPECT_TRUE(monitor_.Start());
    EXPECT_TRUE(GetArpClient());
    EXPECT_FALSE(IsUnicast());
    EXPECT_FALSE(GetSendRequestCallback().IsCancelled());
  }
  void ReportResume() {
    monitor_.OnAfterResume();
  }
  bool SimulateReceivePacket(ArpPacket *packet, ByteString *sender) {
    packet->set_operation(rx_packet_.operation());
    packet->set_local_ip_address(rx_packet_.local_ip_address());
    packet->set_remote_ip_address(rx_packet_.remote_ip_address());
    packet->set_local_mac_address(rx_packet_.local_mac_address());
    packet->set_remote_mac_address(rx_packet_.remote_mac_address());
    return true;
  }
  void ReceiveResponse(uint16_t operation,
                       const IPAddress &local_ip,
                       const ByteString &local_mac,
                       const IPAddress &remote_ip,
                       const ByteString &remote_mac) {
    rx_packet_.set_operation(operation);
    rx_packet_.set_local_ip_address(local_ip);
    rx_packet_.set_local_mac_address(local_mac);
    rx_packet_.set_remote_ip_address(remote_ip);
    rx_packet_.set_remote_mac_address(remote_mac);

    EXPECT_CALL(*client_, ReceivePacket(_, _))
        .WillOnce(Invoke(this, &LinkMonitorTest::SimulateReceivePacket));
    monitor_.ReceiveResponse(0);
  }
  void ReceiveCorrectResponse() {
    ReceiveResponse(ARPOP_REPLY, gateway_ip_, gateway_mac_,
                    local_ip_, local_mac_);
  }
  void RunUnicastResponseCycle(int cycle_count,
                               bool should_respond_to_unicast_probes,
                               bool should_count_failures) {
    // This method expects the LinkMonitor to be in a state where it
    // is waiting for a broadcast response.  It also returns with the
    // LinkMonitor in the same state.
    // Successful receptions.
    EXPECT_CALL(metrics_, SendToUMA(
        HasSubstr("LinkMonitorResponseTimeSample"), 0, _, _, _))
        .Times(cycle_count * (should_respond_to_unicast_probes ? 2 : 1));
    // Unsuccessful unicast receptions.
    EXPECT_CALL(metrics_, SendToUMA(
        HasSubstr("LinkMonitorResponseTimeSample"),
        GetDefaultTestPeriodMilliseconds(),
        _, _, _)).Times(cycle_count *
                        (should_respond_to_unicast_probes ? 0 : 1));

    // Account for any successes / failures before we started.
    int expected_broadcast_success_count = GetBroadcastSuccessCount();
    int expected_unicast_success_count = GetUnicastSuccessCount();
    int expected_unicast_failure_count = GetUnicastFailureCount();

    for (int i = 0; i < cycle_count; ++i) {
      // Respond to the pending broadcast request.
      ReceiveCorrectResponse();

      // Unicast ARP.
      ExpectTransmit(true, GetDefaultTestPeriodMilliseconds());
      TriggerRequestTimer();
      if (should_respond_to_unicast_probes) ReceiveCorrectResponse();

      // Initiate broadcast ARP.
      ExpectTransmit(false, GetDefaultTestPeriodMilliseconds());
      TriggerRequestTimer();

      ++expected_broadcast_success_count;
      if (should_respond_to_unicast_probes) {
        ++expected_unicast_success_count;
        expected_unicast_failure_count = 0;
      } else {
        if (should_count_failures) {
          ++expected_unicast_failure_count;
        }
        expected_unicast_success_count = 0;
      }
      EXPECT_EQ(expected_unicast_failure_count, GetUnicastFailureCount());
      EXPECT_EQ(expected_unicast_success_count, GetUnicastSuccessCount());
      EXPECT_EQ(0, GetBroadcastFailureCount());
      EXPECT_EQ(expected_broadcast_success_count, GetBroadcastSuccessCount());
    }
  }
  bool IsGatewayFound() {
    return monitor_.IsGatewayFound();
  }

  MockEventDispatcher dispatcher_;
  StrictMock<MockMetrics> metrics_;
  MockControl control_;
  NiceMock<MockDeviceInfo> device_info_;
  scoped_refptr<MockConnection> connection_;
  StrictMock<LinkMonitorForTest> monitor_;
  MockTime time_;
  struct timeval time_val_;
  // This is owned by the LinkMonitor, and only tracked here for EXPECT*().
  MockArpClient *client_;
  // This is owned by the test until it is handed to the LinkMonitorForTest
  // and placed // in client_ above.
  MockArpClient *next_client_;
  IPAddress gateway_ip_;
  IPAddress local_ip_;
  ByteString gateway_mac_;
  ByteString local_mac_;
  ByteString zero_mac_;
  ArpPacket rx_packet_;
  bool link_scope_logging_was_enabled_;
  const string interface_name_;
};


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

TEST_F(LinkMonitorTest, StartFailedGetMACAddress) {
  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log,
      Log(logging::LOG_ERROR, _,
          HasSubstr("Could not get local MAC address"))).Times(1);
  EXPECT_CALL(device_info_, GetMACAddress(0, _)).WillOnce(Return(false));
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"), Metrics::kLinkMonitorMacAddressNotFound,
      _));
  EXPECT_CALL(monitor_, CreateClient()).Times(0);
  EXPECT_FALSE(monitor_.Start());
  ExpectReset();
}

TEST_F(LinkMonitorTest, StartFailedCreateClient) {
  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log,
      Log(logging::LOG_ERROR, _,
          HasSubstr("Failed to start ARP client"))).Times(1);
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"), Metrics::kLinkMonitorClientStartFailure,
      _));
  EXPECT_CALL(device_info_, GetMACAddress(0, _)).WillOnce(Return(true));
  EXPECT_CALL(monitor_, CreateClient()).WillOnce(Return(false));
  EXPECT_FALSE(monitor_.Start());
  ExpectReset();
}

TEST_F(LinkMonitorTest, StartFailedTransmitRequest) {
  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log,
      Log(logging::LOG_ERROR, _,
          HasSubstr("Failed to send ARP"))).Times(1);
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"), Metrics::kLinkMonitorTransmitFailure,
      _));
  EXPECT_CALL(device_info_, GetMACAddress(0, _)).WillOnce(Return(true));
  EXPECT_CALL(monitor_, CreateClient())
      .WillOnce(Invoke(this, &LinkMonitorTest::CreateMockClient));
  EXPECT_CALL(*next_client_, TransmitRequest(_)).WillOnce(Return(false));
  EXPECT_FALSE(monitor_.Start());
  ExpectReset();
}

TEST_F(LinkMonitorTest, StartSuccess) {
  StartMonitor();
}

TEST_F(LinkMonitorTest, Stop) {
  StartMonitor();
  monitor_.Stop();
  ExpectReset();
}

TEST_F(LinkMonitorTest, ReplyReception) {
  StartMonitor();
  const int kResponseTime = 1234;
  AdvanceTime(kResponseTime);
  ScopedMockLog log;

  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log, Log(_, _, HasSubstr("not for our IP"))).Times(1);
  ReceiveResponse(ARPOP_REPLY, gateway_ip_, gateway_mac_,
                  gateway_ip_, local_mac_);
  Mock::VerifyAndClearExpectations(&log);

  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log, Log(_, _, HasSubstr("not for our MAC"))).Times(1);
  ReceiveResponse(ARPOP_REPLY, gateway_ip_, gateway_mac_,
                  local_ip_, gateway_mac_);
  Mock::VerifyAndClearExpectations(&log);

  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log, Log(_, _, HasSubstr("not from the gateway"))).Times(1);
  ReceiveResponse(ARPOP_REPLY, local_ip_, gateway_mac_, local_ip_, local_mac_);
  Mock::VerifyAndClearExpectations(&log);

  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log, Log(_, _, HasSubstr("This is not a reply packet"))).Times(1);
  ReceiveResponse(ARPOP_REQUEST, gateway_ip_, gateway_mac_,
                  local_ip_, local_mac_);
  Mock::VerifyAndClearExpectations(&log);

  EXPECT_TRUE(GetArpClient());
  EXPECT_FALSE(monitor_.GetResponseTimeMilliseconds());
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log, Log(_, _, HasSubstr("Found gateway"))).Times(1);
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), kResponseTime,
       _, _, _)).Times(1);
  EXPECT_CALL(monitor_, GatewayChangeCallbackHandler()).Times(1);
  ReceiveCorrectResponse();
  EXPECT_FALSE(GetArpClient());
  EXPECT_EQ(kResponseTime, monitor_.GetResponseTimeMilliseconds());
  EXPECT_TRUE(IsUnicast());
}

TEST_F(LinkMonitorTest, TimeoutBroadcast) {
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"),
      GetDefaultTestPeriodMilliseconds(),
      _, _, _)).Times(GetFailureThreshold());
  StartMonitor();
  // This value doesn't match real life (the timer in this scenario
  // should advance by LinkMonitor::kDefaultTestPeriodMilliseconds),
  // but this demonstrates the LinkMonitorSecondsToFailure independent
  // from the response-time figures.
  const int kTimeIncrement = 1000;
  for (size_t i = 1; i < GetFailureThreshold(); ++i) {
    ExpectTransmit(false, GetDefaultTestPeriodMilliseconds());
    AdvanceTime(kTimeIncrement);
    TriggerRequestTimer();
    EXPECT_FALSE(IsUnicast());
    EXPECT_EQ(i, GetBroadcastFailureCount());
    EXPECT_EQ(0, GetUnicastFailureCount());
    EXPECT_EQ(0, GetBroadcastSuccessCount());
    EXPECT_EQ(0, GetUnicastSuccessCount());
    EXPECT_EQ(GetDefaultTestPeriodMilliseconds(),
              monitor_.GetResponseTimeMilliseconds());
  }
  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log,
      Log(logging::LOG_ERROR, _,
          HasSubstr("monitor has reached the failure threshold"))).Times(1);
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"),
      Metrics::kLinkMonitorFailureThresholdReached, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorSecondsToFailure"),
      kTimeIncrement * GetFailureThreshold() / 1000, _, _, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("BroadcastErrorsAtFailure"), GetFailureThreshold(), _, _, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("UnicastErrorsAtFailure"), 0, _, _, _));
  EXPECT_FALSE(GetSendRequestCallback().IsCancelled());
  ExpectNoTransmit();
  EXPECT_CALL(monitor_, FailureCallbackHandler());
  AdvanceTime(kTimeIncrement);
  TriggerRequestTimer();
  ExpectReset();
}

TEST_F(LinkMonitorTest, TimeoutUnicast) {
  StartMonitor();

  ScopedMockLog log;
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());
  EXPECT_CALL(log,
      Log(logging::LOG_ERROR, _,
          HasSubstr("monitor has reached the failure threshold"))).Times(0);
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"),
      Metrics::kLinkMonitorFailureThresholdReached, _)).Times(0);
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorSecondsToFailure"), _, _, _, _)).Times(0);
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("BroadcastErrorsAtFailure"), _, _, _, _)).Times(0);
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("UnicastErrorsAtFailure"), _, _, _, _)).Times(0);
  EXPECT_CALL(monitor_, GatewayChangeCallbackHandler()).Times(1);

  // Unicast failures should not cause LinkMonitor errors if we haven't
  // noted the gateway as reliably replying to unicast ARP messages.  Test
  // this by doing threshold - 1 successful unicast responses, followed
  // by a ton of unicast failures.
  RunUnicastResponseCycle(GetUnicastReplyReliabilityThreshold() - 1,
                          true, false);
  EXPECT_EQ(GetUnicastReplyReliabilityThreshold() - 1,
            GetUnicastSuccessCount());
  RunUnicastResponseCycle(GetFailureThreshold() +
                          GetUnicastReplyReliabilityThreshold(), false, false);
  EXPECT_FALSE(GetSendRequestCallback().IsCancelled());
  EXPECT_FALSE(GatewaySupportsUnicastArp());
  EXPECT_EQ(0, GetUnicastSuccessCount());
  EXPECT_EQ(0, GetUnicastFailureCount());

  // Cross the the unicast reliability threshold.
  RunUnicastResponseCycle(GetUnicastReplyReliabilityThreshold() - 1,
                          true, false);
  EXPECT_CALL(log,
      Log(_, _, HasSubstr("Unicast failures will now count")));
  EXPECT_FALSE(GatewaySupportsUnicastArp());
  RunUnicastResponseCycle(1, true, false);
  EXPECT_TRUE(GatewaySupportsUnicastArp());

  // Induce one less failures than will cause a link monitor failure, and
  // confirm that these failures are counted.
  RunUnicastResponseCycle(GetFailureThreshold() - 1, false, true);
  EXPECT_EQ(GetFailureThreshold() - 1, GetUnicastFailureCount());

  Mock::VerifyAndClearExpectations(&log);
  EXPECT_CALL(log, Log(_, _, _)).Times(AnyNumber());

  // Induce a final broadcast success followed by a unicast failure.
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), 0, _, _, _));
  ReceiveCorrectResponse();
  ExpectTransmit(true, GetDefaultTestPeriodMilliseconds());
  TriggerRequestTimer();
  EXPECT_FALSE(GetSendRequestCallback().IsCancelled());

  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"),
      GetDefaultTestPeriodMilliseconds(),
      _, _, _));
  EXPECT_CALL(log,
      Log(logging::LOG_ERROR, _,
          HasSubstr("monitor has reached the failure threshold"))).Times(1);
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"),
      Metrics::kLinkMonitorFailureThresholdReached, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorSecondsToFailure"), 0, _, _, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("BroadcastErrorsAtFailure"), 0, _, _, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("UnicastErrorsAtFailure"), GetFailureThreshold(), _, _, _));
  EXPECT_CALL(monitor_, FailureCallbackHandler());
  ExpectNoTransmit();
  TriggerRequestTimer();
  ExpectReset();
}

TEST_F(LinkMonitorTest, OnAfterResume) {
  const int kFastTestPeriodMilliseconds = GetFastTestPeriodMilliseconds();
  StartMonitor();
  Mock::VerifyAndClearExpectations(&monitor_);

  // Resume should preserve the fact that we haven't resolved the gateway's MAC,
  // as well as the fact that the gateway suppports unicast ARP.
  EXPECT_FALSE(IsGatewayFound());
  EXPECT_FALSE(GatewaySupportsUnicastArp());
  ExpectRestart(kFastTestPeriodMilliseconds);
  ReportResume();
  EXPECT_FALSE(IsGatewayFound());
  EXPECT_FALSE(GatewaySupportsUnicastArp());

  // This is the expected normal case, so let's test that.  The
  // OnAfterResumeWithoutUnicast test below verifies when this is not true.
  SetGatewaySupportsUnicastArp(true);

  // After resume, we should use the fast test period...
  ExpectRestart(kFastTestPeriodMilliseconds);
  ReportResume();
  EXPECT_EQ(kFastTestPeriodMilliseconds, GetCurrentTestPeriodMilliseconds());

  // ...and the fast period should be used for reporting failure to UMA...
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), kFastTestPeriodMilliseconds,
      _, _, _));
  ExpectTransmit(false, kFastTestPeriodMilliseconds);
  TriggerRequestTimer();

  // ...and the period should be reset after correct responses on both
  // broadcast and unicast.
  const int kResponseTime = 12;
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), kResponseTime,  _, _, _))
      .Times(2);
  EXPECT_CALL(monitor_, GatewayChangeCallbackHandler()).Times(1);
  AdvanceTime(kResponseTime);
  ReceiveCorrectResponse();
  EXPECT_EQ(GetFastTestPeriodMilliseconds(),
            GetCurrentTestPeriodMilliseconds());  // Don't change yet.
  ExpectTransmit(true, kFastTestPeriodMilliseconds);
  TriggerRequestTimer();
  AdvanceTime(kResponseTime);
  ReceiveCorrectResponse();
  EXPECT_EQ(1, GetBroadcastSuccessCount());
  EXPECT_EQ(1, GetUnicastSuccessCount());
  EXPECT_EQ(GetDefaultTestPeriodMilliseconds(),
            GetCurrentTestPeriodMilliseconds());

  // Resume should preserve the fact that we _have_ resolved the gateway's MAC.
  EXPECT_TRUE(IsGatewayFound());
  ExpectRestart(kFastTestPeriodMilliseconds);
  ReportResume();
  EXPECT_TRUE(IsGatewayFound());
  EXPECT_TRUE(GatewaySupportsUnicastArp());

  // Failure should happen just like normal.
  ExpectRestart(kFastTestPeriodMilliseconds);
  ReportResume();
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), kFastTestPeriodMilliseconds,
      _, _, _))
      .Times(GetFailureThreshold());
  EXPECT_CALL(metrics_, SendEnumToUMA(
      HasSubstr("LinkMonitorFailure"),
      Metrics::kLinkMonitorFailureThresholdReached, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorSecondsToFailure"), _, _, _, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("BroadcastErrorsAtFailure"), GetFailureThreshold() / 2 + 1,
      _, _, _));
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("UnicastErrorsAtFailure"), GetFailureThreshold() / 2,
      _, _, _));
  EXPECT_CALL(monitor_, FailureCallbackHandler());
  bool unicast_probe = true;
  for (size_t i = 1 ; i < GetFailureThreshold(); ++i) {
    ExpectTransmit(unicast_probe, GetFastTestPeriodMilliseconds());
    TriggerRequestTimer();
    unicast_probe = !unicast_probe;
  }
  TriggerRequestTimer();
  ExpectReset();
}

TEST_F(LinkMonitorTest, OnAfterResumeWithoutUnicast) {
  const int kFastTestPeriodMilliseconds = GetFastTestPeriodMilliseconds();
  StartMonitor();
  Mock::VerifyAndClearExpectations(&monitor_);

  // Resume should preserve the fact that we haven't resolved the gateway's MAC.
  EXPECT_FALSE(IsGatewayFound());
  EXPECT_FALSE(GatewaySupportsUnicastArp());
  ExpectRestart(kFastTestPeriodMilliseconds);
  ReportResume();
  EXPECT_FALSE(IsGatewayFound());
  EXPECT_FALSE(GatewaySupportsUnicastArp());

  // After resume, we should use the fast test period...
  ExpectRestart(kFastTestPeriodMilliseconds);
  ReportResume();
  EXPECT_EQ(kFastTestPeriodMilliseconds, GetCurrentTestPeriodMilliseconds());

  // ...and the fast period should be used for reporting failure to UMA...
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), kFastTestPeriodMilliseconds,
      _, _, _));
  ExpectTransmit(false, kFastTestPeriodMilliseconds);
  TriggerRequestTimer();

  // ...and the period should be reset after correct response on just the
  // broadcast response since the link monitor doesn't trust unicast.
  const int kResponseTime = 12;
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), kResponseTime,  _, _, _));
  AdvanceTime(kResponseTime);
  EXPECT_CALL(monitor_, GatewayChangeCallbackHandler()).Times(1);
  ReceiveCorrectResponse();
  EXPECT_EQ(GetDefaultTestPeriodMilliseconds(),
            GetCurrentTestPeriodMilliseconds());
}

TEST_F(LinkMonitorTest, Average) {
  const int kSamples[] = { 200, 950, 1200, 4096, 5000,
                           86, 120, 3060, 842, 750 };
  const size_t filter_depth = GetMaxResponseSampleFilterDepth();
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), _, _, _, _))
      .Times(arraysize(kSamples));
  EXPECT_CALL(monitor_, GatewayChangeCallbackHandler()).Times(1);
  ASSERT_GT(arraysize(kSamples), filter_depth);
  StartMonitor();
  size_t i = 0;
  int sum = 0;
  for (; i < filter_depth; ++i) {
    AdvanceTime(kSamples[i]);
    ReceiveCorrectResponse();
    sum += kSamples[i];
    EXPECT_EQ(sum / (i + 1), monitor_.GetResponseTimeMilliseconds());
    SendNextRequest();
  }
  for (; i < arraysize(kSamples); ++i) {
    AdvanceTime(kSamples[i]);
    ReceiveCorrectResponse();
    sum = (sum + kSamples[i]) * filter_depth / (filter_depth + 1);
    EXPECT_EQ(sum / filter_depth, monitor_.GetResponseTimeMilliseconds());
    SendNextRequest();
  }
}

TEST_F(LinkMonitorTest, ImpulseResponse) {
  const int kNormalValue = 50;
  const int kExceptionalValue = 5000;
  const int filter_depth = GetMaxResponseSampleFilterDepth();
  EXPECT_CALL(metrics_, SendToUMA(
      HasSubstr("LinkMonitorResponseTimeSample"), _, _, _, _))
      .Times(AnyNumber());
  EXPECT_CALL(monitor_, GatewayChangeCallbackHandler()).Times(1);
  StartMonitor();
  for (int i = 0; i < filter_depth * 2; ++i) {
    AdvanceTime(kNormalValue);
    ReceiveCorrectResponse();
    EXPECT_EQ(kNormalValue, monitor_.GetResponseTimeMilliseconds());
    SendNextRequest();
  }
  AdvanceTime(kExceptionalValue);
  ReceiveCorrectResponse();
  // Our expectation is that an impulse input will be a
  // impulse_height / (filter_depth + 1) increase to the running average.
  int expected_impulse_response =
      kNormalValue + (kExceptionalValue - kNormalValue) / (filter_depth + 1);
  EXPECT_EQ(expected_impulse_response, monitor_.GetResponseTimeMilliseconds());
  SendNextRequest();

  // From here, if we end up continuing to receive normal values, our
  // running average should decay backwards to the normal value.
  const int failsafe = 100;
  int last_value = monitor_.GetResponseTimeMilliseconds();
  for (int i = 0; i < failsafe && last_value != kNormalValue; ++i) {
    AdvanceTime(kNormalValue);
    ReceiveCorrectResponse();
    // We should advance monotonically (but not necessarily linearly)
    // back towards the normal value.
    EXPECT_GE(last_value, monitor_.GetResponseTimeMilliseconds());
    SendNextRequest();
    last_value = monitor_.GetResponseTimeMilliseconds();
  }
  EXPECT_EQ(kNormalValue, last_value);
}

TEST_F(LinkMonitorTest, HardwareAddressToString) {
  const uint8_t address0[] = { 0, 1, 2, 3, 4, 5 };
  EXPECT_EQ("00:01:02:03:04:05",
            HardwareAddressToString(ByteString(address0, arraysize(address0))));
  const uint8_t address1[] = { 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd };
  EXPECT_EQ("88:99:aa:bb:cc:dd",
            HardwareAddressToString(ByteString(address1, arraysize(address1))));
}

}  // namespace shill