dhcp_options_writer_unittest.cc

//
// 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_writer.h>

#include <netinet/in.h>

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

#include <gtest/gtest.h>
#include <shill/net/byte_string.h>

#include "dhcp_client/dhcp_options.h"

using shill::ByteString;
namespace dhcp_client {

namespace {
const uint8_t kFakeOptionCode1 = 3;
const uint8_t kFakeOptionCode2 = 45;
const uint8_t kFakeOptionCode3 = 251;
}  // namespace


class DHCPOptionsWriterTest : public testing::Test {
 protected:
  DHCPOptionsWriter* options_writer_;
};

TEST_F(DHCPOptionsWriterTest, WriteUInt8) {
  const uint8_t kFakeUInt8Option = 0x22;
  const uint8_t kFakeUInt8OptionResult[] = {
      kFakeOptionCode1,
      sizeof(uint8_t),
      0x22};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteUInt8Option(&option,
                                                 kFakeOptionCode1,
                                                 kFakeUInt8Option);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt8OptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteUInt16) {
  const uint16_t kFakeUInt16Option = 0x1516;
  const uint8_t kFakeUInt16OptionResult[] = {
      kFakeOptionCode2,
      sizeof(uint16_t),
      // Use the network byte order.
      0x15, 0x16};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteUInt16Option(&option,
                                                  kFakeOptionCode2,
                                                  kFakeUInt16Option);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt16OptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteUInt32) {
  const uint32_t kFakeUInt32Option = 0x32a0bf01;
  const uint8_t kFakeUInt32OptionResult[] = {
      kFakeOptionCode3,
      sizeof(uint32_t),
      // Use the network byte order.
      0x32, 0xa0, 0xbf, 0x01};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteUInt32Option(&option,
                                                  kFakeOptionCode3,
                                                  kFakeUInt32Option);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt32OptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteUInt8List) {
  const std::vector<uint8_t> kFakeUInt8ListOption =
      {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
  const uint8_t kFakeUInt8ListOptionResult[] = {
      kFakeOptionCode1,
      static_cast<uint8_t>(kFakeUInt8ListOption.size()),
      0x01, 0x02, 0x03, 0x04, 0x05, 0x06};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteUInt8ListOption(&option,
                                                     kFakeOptionCode1,
                                                     kFakeUInt8ListOption);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt8ListOptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteUInt16List) {
  const std::vector<uint16_t> kFakeUInt16ListOption =
      {0xb1a2, 0x0264, 0xdc03, 0x92c4, 0xa500, 0x0010};
  const uint8_t kFakeUInt16ListOptionResult[] = {
      kFakeOptionCode2,
      static_cast<uint8_t>(sizeof(uint16_t) * kFakeUInt16ListOption.size()),
      // Use the network byte order.
      0xb1, 0xa2, 0x02, 0x64, 0xdc, 0x03, 0x92, 0xc4, 0xa5, 0x00, 0x00, 0x10};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteUInt16ListOption(&option,
                                                      kFakeOptionCode2,
                                                      kFakeUInt16ListOption);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt16ListOptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteUInt32List) {
  const std::vector<uint32_t> kFakeUInt32ListOption =
      {0x03a64301, 0x03f52614, 0x7c5d9eff, 0x0138b26e};
  const uint8_t kFakeUInt32ListOptionResult[] = {
      kFakeOptionCode3,
      static_cast<uint8_t>(sizeof(uint32_t) * kFakeUInt32ListOption.size()),
      // Use the network byte order.
      0x03, 0xa6, 0x43, 0x01, 0x03, 0xf5, 0x26, 0x14,
      0x7c, 0x5d, 0x9e, 0xff, 0x01, 0x38, 0xb2, 0x6e};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteUInt32ListOption(&option,
                                                      kFakeOptionCode3,
                                                      kFakeUInt32ListOption);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt32ListOptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteUInt32PairList) {
  const std::vector<std::pair<uint32_t, uint32_t>> kFakeUInt32PairListOption =
      {{0x03b576a1, 0xfa070054}, {0x650c3d22, 0x1397e5bb}};
  const uint8_t kFakeUInt32PairListOptionResult[] = {
      kFakeOptionCode1,
      static_cast<uint8_t>
          (sizeof(uint32_t) * 2 * kFakeUInt32PairListOption.size()),
      // Use the network byte order.
      0x03, 0xb5, 0x76, 0xa1, 0xfa, 0x07, 0x00, 0x54,
      0x65, 0x0c, 0x3d, 0x22, 0x13, 0x97, 0xe5, 0xbb};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length =
      options_writer_->WriteUInt32PairListOption(&option,
                                                 kFakeOptionCode1,
                                                 kFakeUInt32PairListOption);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeUInt32PairListOptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteString) {
  const std::string kFakeStringOption = "fakestring";
  const uint8_t kFakeStringOptionResult[] = {
      kFakeOptionCode1,
      static_cast<uint8_t>(kFakeStringOption.size()),
      'f', 'a', 'k', 'e', 's', 't', 'r', 'i', 'n', 'g'};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteStringOption(&option,
                                                  kFakeOptionCode1,
                                                  kFakeStringOption);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeStringOptionResult,
                           length));
}


TEST_F(DHCPOptionsWriterTest, WriteBoolTrue) {
  const uint8_t kFakeBoolOptionTrue = true;
  const uint8_t kFakeBoolOptionResultTrue[] = {
    kFakeOptionCode1,
    sizeof(uint8_t),
    0x01};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteBoolOption(&option,
                                                kFakeOptionCode1,
                                                kFakeBoolOptionTrue);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeBoolOptionResultTrue,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteBoolFalse) {
  const uint8_t kFakeBoolOptionFalse = false;
  const uint8_t kFakeBoolOptionResultFalse[] = {
      kFakeOptionCode2,
      sizeof(uint8_t),
      0x00};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteBoolOption(&option,
                                                kFakeOptionCode2,
                                                kFakeBoolOptionFalse);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeBoolOptionResultFalse,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteByteArray) {
  const ByteString kFakeByteArrayOption =
      ByteString({0x06, 0x05, 0x04, 0x03, 0x02, 0x01});
  const uint8_t kFakeByteArrayOptionResult[] = {
      kFakeOptionCode1,
      static_cast<uint8_t>(kFakeByteArrayOption.GetLength()),
      0x06, 0x05, 0x04, 0x03, 0x02, 0x01};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteByteArrayOption(&option,
                                                     kFakeOptionCode1,
                                                     kFakeByteArrayOption);
  EXPECT_NE(-1, length);
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeByteArrayOptionResult,
                           length));
}

TEST_F(DHCPOptionsWriterTest, WriteEndTag) {
  const std::string kFakeStringOption = "fakestring1";
  const uint8_t kFakeStringOptionResult[] = {
      kFakeOptionCode1,
      static_cast<uint8_t>(kFakeStringOption.size()),
      'f', 'a', 'k', 'e', 's', 't', 'r', 'i', 'n', 'g', '1'};

  ByteString option;
  options_writer_ = DHCPOptionsWriter::GetInstance();
  int length = options_writer_->WriteStringOption(&option,
                                                  kFakeOptionCode1,
                                                  kFakeStringOption);
  EXPECT_NE(-1, length);
  EXPECT_NE(-1, options_writer_->WriteEndTag(&option));
  EXPECT_EQ(0, std::memcmp(option.GetConstData(),
                           kFakeStringOptionResult,
                           length));
  EXPECT_EQ(kDHCPOptionEnd, *(option.GetConstData() + length));
}

}  // namespace dhcp_client