blob: 88d37c0a41a78476d9e7c85be028c189efb76d2c [file] [log] [blame]
//
// Copyright (C) 2015 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 <dhcp_client/dhcp_options_parser.h>
#include <netinet/in.h>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <gtest/gtest.h>
#include <shill/net/byte_string.h>
using shill::ByteString;
namespace {
const uint8_t kFakeUInt8Option[] = {0x02};
const uint8_t kFakeUInt8OptionLength = 1;
const uint8_t kFakeUInt16Option[] = {0x2a, 0x01};
const uint8_t kFakeUInt16OptionLength = 2;
const uint8_t kFakeUInt32Option[] = {0x01, 0x02, 0x00, 0xfa};
const uint8_t kFakeUInt32OptionLength = 4;
const uint8_t kFakeUInt8ListOption[] =
{0x01, 0x02, 0x00, 0xfa, 0x23, 0xae, 0x1f, 0x00};
const uint8_t kFakeUInt8ListOptionLength = 8;
const uint8_t kFakeUInt16ListOption[] =
{0xaa, 0x26, 0x4b, 0x00, 0xff, 0xc2, 0xcf, 0x0d, 0xe0, 0x01};
const uint8_t kFakeUInt16ListOptionLength = 10;
const uint8_t kFakeUInt32ListOption[] = {0x01, 0x02, 0x00, 0xfa,
0x23, 0xae, 0x1f, 0x00,
0x0c, 0x53, 0x33, 0x10,
0x47, 0x80, 0xb3, 0xff};
const uint8_t kFakeUInt32ListOptionLength = 16;
const uint8_t kFakeUInt32PairListOption[] = {0x21, 0xa0, 0xeb, 0x73,
0x01, 0x00, 0x1f, 0x10,
0xc9, 0x22, 0x3a, 0x37,
0xff, 0x00, 0xbe, 0xd0};
const uint8_t kFakeUInt32PairListOptionLength = 16;
const unsigned char kFakeStringOption[] =
{'f', 'a', 'k', 'e', 's', 't', 'r', 'i', 'n', 'g'};
const uint8_t kFakeStringOptionLength = 10;
const unsigned char kFakeByteArrayOption[] =
{'f', 'a', 'k', 'e', 'b', 'y', 't', 'e', 'a', 'r', 'r', 'a', 'y'};
const uint8_t kFakeBoolOptionEnable[] = {0x01};
const uint8_t kFakeBoolOptionDisable[] = {0x00};
const uint8_t kFakeBoolOptionLength = 1;
} // namespace
namespace dhcp_client {
class ParserTest : public testing::Test {
protected:
std::unique_ptr<DHCPOptionsParser> parser_;
};
TEST_F(ParserTest, ParseUInt8) {
parser_.reset(new UInt8Parser());
uint8_t value;
EXPECT_TRUE(parser_->GetOption(kFakeUInt8Option,
kFakeUInt8OptionLength,
&value));
EXPECT_EQ(*kFakeUInt8Option, value);
}
TEST_F(ParserTest, ParseUInt16) {
parser_.reset(new UInt16Parser());
uint16_t value;
uint16_t target_value =
*reinterpret_cast<const uint16_t*>(kFakeUInt16Option);
target_value = ntohs(target_value);
EXPECT_TRUE(parser_->GetOption(kFakeUInt16Option,
kFakeUInt16OptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseUInt32) {
parser_.reset(new UInt32Parser());
uint32_t value;
uint32_t target_value =
*reinterpret_cast<const uint32_t*>(kFakeUInt32Option);
target_value = ntohl(target_value);
EXPECT_TRUE(parser_->GetOption(kFakeUInt32Option,
kFakeUInt32OptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseUInt8List) {
parser_.reset(new UInt8ListParser());
std::vector<uint8_t> value;
std::vector<uint8_t> target_value;
uint8_t length = kFakeUInt8ListOptionLength;
const uint8_t* uint8_list =
reinterpret_cast<const uint8_t*>(kFakeUInt8ListOption);
target_value = std::vector<uint8_t>(uint8_list, uint8_list + length);
EXPECT_TRUE(parser_->GetOption(kFakeUInt8ListOption,
kFakeUInt8ListOptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseUInt16List) {
parser_.reset(new UInt16ListParser());
std::vector<uint16_t> value;
std::vector<uint16_t> target_value;
std::vector<uint16_t> target_value_net_order;
int length = kFakeUInt16ListOptionLength / sizeof(uint16_t);
const uint16_t* uint16_list =
reinterpret_cast<const uint16_t*>(kFakeUInt16ListOption);
target_value_net_order =
std::vector<uint16_t>(uint16_list, uint16_list + length);
for (uint16_t element : target_value_net_order) {
target_value.push_back(ntohs(element));
}
EXPECT_TRUE(parser_->GetOption(kFakeUInt16ListOption,
kFakeUInt16ListOptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseUInt32List) {
parser_.reset(new UInt32ListParser());
std::vector<uint32_t> value;
std::vector<uint32_t> target_value;
std::vector<uint32_t> target_value_net_order;
int length = kFakeUInt32ListOptionLength / sizeof(uint32_t);
const uint32_t* uint32_list =
reinterpret_cast<const uint32_t*>(kFakeUInt32ListOption);
target_value_net_order =
std::vector<uint32_t>(uint32_list, uint32_list + length);
for (uint32_t element : target_value_net_order) {
target_value.push_back(ntohl(element));
}
EXPECT_TRUE(parser_->GetOption(kFakeUInt32ListOption,
kFakeUInt32ListOptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseUInt32PairList) {
parser_.reset(new UInt32PairListParser());
int length = kFakeUInt32PairListOptionLength / (2 * sizeof(uint32_t));
const uint32_t* uint32_array =
reinterpret_cast<const uint32_t*>(kFakeUInt32PairListOption);
std::vector<uint32_t> uint32_vector =
std::vector<uint32_t>(uint32_array, uint32_array + length * 2);
std::vector<std::pair<uint32_t, uint32_t>> target_value;
for (int i = 0; i < length; i++) {
target_value.push_back(
std::pair<uint32_t, uint32_t>(ntohl(uint32_vector[2 * i]),
ntohl(uint32_vector[2 * i + 1])));
}
std::vector<std::pair<uint32_t, uint32_t>> value;
EXPECT_TRUE(parser_->GetOption(kFakeUInt32PairListOption,
kFakeUInt32PairListOptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseBoolEnable) {
parser_.reset(new BoolParser());
bool value;
EXPECT_TRUE(parser_->GetOption(kFakeBoolOptionEnable,
kFakeBoolOptionLength,
&value));
EXPECT_TRUE(value);
}
TEST_F(ParserTest, ParseBoolDisable) {
parser_.reset(new BoolParser());
bool value;
EXPECT_TRUE(parser_->GetOption(kFakeBoolOptionDisable,
kFakeBoolOptionLength,
&value));
EXPECT_FALSE(value);
}
TEST_F(ParserTest, ParseString) {
parser_.reset(new StringParser());
std::string value;
std::string target_value;
target_value.assign(reinterpret_cast<const char*>(kFakeStringOption),
kFakeStringOptionLength);
EXPECT_TRUE(parser_->GetOption(kFakeStringOption,
kFakeStringOptionLength,
&value));
EXPECT_EQ(target_value, value);
}
TEST_F(ParserTest, ParseByteArray) {
parser_.reset(new ByteArrayParser());
ByteString value;
ByteString target_value(reinterpret_cast<const char*>(kFakeByteArrayOption),
sizeof(kFakeByteArrayOption));
EXPECT_TRUE(parser_->GetOption(kFakeByteArrayOption,
sizeof(kFakeByteArrayOption),
&value));
EXPECT_TRUE(target_value.Equals(value));
}
} // namespace dhcp_client