// Copyright 2018 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "shill/technology.h"

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

#include "shill/error.h"

using testing::ElementsAre;

namespace shill {

TEST(TechnologyTest, TechnologyFromName) {
  EXPECT_EQ(Technology::kEthernet, TechnologyFromName("ethernet"));
  EXPECT_EQ(Technology::kEthernetEap, TechnologyFromName("etherneteap"));
  EXPECT_EQ(Technology::kWiFi, TechnologyFromName("wifi"));
  EXPECT_EQ(Technology::kCellular, TechnologyFromName("cellular"));
  EXPECT_EQ(Technology::kTunnel, TechnologyFromName("tunnel"));
  EXPECT_EQ(Technology::kLoopback, TechnologyFromName("loopback"));
  EXPECT_EQ(Technology::kVPN, TechnologyFromName("vpn"));
  EXPECT_EQ(Technology::kPPP, TechnologyFromName("ppp"));
  EXPECT_EQ(Technology::kGuestInterface, TechnologyFromName("guest_interface"));
  EXPECT_EQ(Technology::kUnknown, TechnologyFromName("foo"));
  EXPECT_EQ(Technology::kUnknown, TechnologyFromName(""));
}

TEST(TechnologyTest, TechnologyName) {
  EXPECT_EQ("ethernet", TechnologyName(Technology::kEthernet));
  EXPECT_EQ("etherneteap", TechnologyName(Technology::kEthernetEap));
  EXPECT_EQ("wifi", TechnologyName(Technology::kWiFi));
  EXPECT_EQ("cellular", TechnologyName(Technology::kCellular));
  EXPECT_EQ("tunnel", TechnologyName(Technology::kTunnel));
  EXPECT_EQ("loopback", TechnologyName(Technology::kLoopback));
  EXPECT_EQ("vpn", TechnologyName(Technology::kVPN));
  EXPECT_EQ("ppp", TechnologyName(Technology::kPPP));
  EXPECT_EQ("guest_interface", TechnologyName(Technology::kGuestInterface));
  EXPECT_EQ("unknown", TechnologyName(Technology::kUnknown));
}

TEST(TechnologyTest, TechnologyFromStorageGroup) {
  EXPECT_EQ(Technology::kVPN, TechnologyFromStorageGroup("vpn"));
  EXPECT_EQ(Technology::kVPN, TechnologyFromStorageGroup("vpn_a"));
  EXPECT_EQ(Technology::kVPN, TechnologyFromStorageGroup("vpn__a"));
  EXPECT_EQ(Technology::kVPN, TechnologyFromStorageGroup("vpn_a_1"));
  EXPECT_EQ(Technology::kUnknown, TechnologyFromStorageGroup("_vpn"));
  EXPECT_EQ(Technology::kUnknown, TechnologyFromStorageGroup("_"));
  EXPECT_EQ(Technology::kUnknown, TechnologyFromStorageGroup(""));
}

TEST(TechnologyTest, GetTechnologyVectorFromStringWithValidTechnologyNames) {
  std::vector<Technology> technologies;
  Error error;

  EXPECT_TRUE(GetTechnologyVectorFromString("", &technologies, &error));
  EXPECT_THAT(technologies, ElementsAre());
  EXPECT_TRUE(error.IsSuccess());

  EXPECT_TRUE(GetTechnologyVectorFromString("ethernet", &technologies, &error));
  EXPECT_THAT(technologies, ElementsAre(Technology::kEthernet));
  EXPECT_TRUE(error.IsSuccess());

  EXPECT_TRUE(
      GetTechnologyVectorFromString("ethernet,vpn", &technologies, &error));
  EXPECT_THAT(technologies,
              ElementsAre(Technology::kEthernet, Technology::kVPN));
  EXPECT_TRUE(error.IsSuccess());

  EXPECT_TRUE(GetTechnologyVectorFromString("wifi,ethernet,vpn", &technologies,
                                            &error));
  EXPECT_THAT(
      technologies,
      ElementsAre(Technology::kWiFi, Technology::kEthernet, Technology::kVPN));
  EXPECT_TRUE(error.IsSuccess());
}

TEST(TechnologyTest, GetTechnologyVectorFromStringWithInvalidTechnologyNames) {
  std::vector<Technology> technologies;
  Error error;

  EXPECT_FALSE(GetTechnologyVectorFromString("foo", &technologies, &error));
  EXPECT_EQ(Error::kInvalidArguments, error.type());
  EXPECT_EQ("foo is an unknown technology name", error.message());

  EXPECT_FALSE(
      GetTechnologyVectorFromString("ethernet,bar", &technologies, &error));
  EXPECT_EQ(Error::kInvalidArguments, error.type());
  EXPECT_EQ("bar is an unknown technology name", error.message());

  EXPECT_FALSE(
      GetTechnologyVectorFromString("ethernet,foo,vpn", &technologies, &error));
  EXPECT_EQ(Error::kInvalidArguments, error.type());
  EXPECT_EQ("foo is an unknown technology name", error.message());
}

TEST(TechnologyTest,
     GetTechnologyVectorFromStringWithDuplicateTechnologyNames) {
  std::vector<Technology> technologies;
  Error error;

  EXPECT_FALSE(GetTechnologyVectorFromString("ethernet,vpn,ethernet",
                                             &technologies, &error));
  EXPECT_EQ(Error::kInvalidArguments, error.type());
  EXPECT_EQ("ethernet is duplicated in the list", error.message());
}

}  // namespace shill