//
// 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/net/byte_string.h"

#include <arpa/inet.h>
#include <endian.h>

#include <string>
#include <utility>

#include <gtest/gtest.h>

using testing::Test;
using std::string;

namespace shill {

namespace {
const unsigned char kTest1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const char kTest1HexString[] = "00010203040506070809";
const char kTest1HexSubstring[] = "0001020304050607";
const char kTest1HexSubstringReordered[] = "0302010007060504";
const unsigned char kTest2[] = { 1, 2, 3, 0xa };
const char kTest2HexString[] = "0102030A";
const unsigned int kTest2Uint32 = 0x0102030a;
const unsigned char kTest3[] = { 0, 0, 0, 0 };
const char kTest4[] = "Hello world";
const unsigned char kTest5[] = { 1, 2, 3 };
const unsigned char kTest6[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
}  // namespace

class ByteStringTest : public Test {
 public:
  bool IsCPUSameAsNetOrder() {
    const uint32_t kTestValue = 0x12345678;
    return htonl(kTestValue) == kTestValue;
  }
};

TEST_F(ByteStringTest, Empty) {
  uint32_t val;

  ByteString bs1(0);
  EXPECT_TRUE(bs1.IsEmpty());
  EXPECT_EQ(0, bs1.GetLength());
  EXPECT_EQ(nullptr, bs1.GetData());
  EXPECT_FALSE(bs1.ConvertToNetUInt32(&val));
  EXPECT_TRUE(bs1.IsZero());
}

TEST_F(ByteStringTest, NonEmpty) {
  ByteString bs1(kTest1, sizeof(kTest1));
  uint32_t val;

  EXPECT_FALSE(bs1.IsEmpty());
  ASSERT_NE(nullptr, bs1.GetData());
  EXPECT_EQ(sizeof(kTest1), bs1.GetLength());
  for (unsigned int i = 0; i < sizeof(kTest1); i++) {
    EXPECT_EQ(bs1.GetData()[i], kTest1[i]);
  }
  EXPECT_FALSE(bs1.ConvertToNetUInt32(&val));
  EXPECT_FALSE(bs1.IsZero());

  // Build a ByteString (different to bs1), verify that the new ByteString
  // looks as expected, verify that it's different to bs1.
  ByteString bs2(kTest2, sizeof(kTest2));
  ASSERT_NE(nullptr, bs2.GetData());
  EXPECT_EQ(sizeof(kTest2), bs2.GetLength());
  for (unsigned int i = 0; i < sizeof(kTest2); i++) {
    EXPECT_EQ(bs2.GetData()[i], kTest2[i]);
  }
  EXPECT_FALSE(bs2.IsZero());
  EXPECT_FALSE(bs2.Equals(bs1));

  // Build _another_ ByteString (different to bs1 and bs2), verify that the
  // new ByteString looks as expected, verify that it's different to bs1 and
  // bs2.
  ByteString bs3(kTest3, sizeof(kTest3));
  ASSERT_NE(nullptr, bs3.GetData());
  EXPECT_EQ(sizeof(kTest3), bs3.GetLength());
  for (unsigned int i = 0; i < sizeof(kTest3); i++) {
    EXPECT_EQ(bs3.GetData()[i], kTest3[i]);
  }
  EXPECT_TRUE(bs3.IsZero());
  EXPECT_FALSE(bs2.Equals(bs1));
  EXPECT_FALSE(bs3.Equals(bs1));

  // Check two equal ByteStrings.
  ByteString bs6(kTest1, sizeof(kTest1));
  EXPECT_TRUE(bs6.Equals(bs1));
}

TEST_F(ByteStringTest, CopyTerminator) {
  ByteString bs4(string(kTest4), false);
  EXPECT_EQ(strlen(kTest4), bs4.GetLength());
  EXPECT_EQ(0, memcmp(kTest4, bs4.GetData(), bs4.GetLength()));

  ByteString bs5(string(kTest4), true);
  EXPECT_EQ(strlen(kTest4) + 1, bs5.GetLength());
  EXPECT_EQ(0, memcmp(kTest4, bs5.GetData(), bs5.GetLength()));
}

TEST_F(ByteStringTest, SubString) {
  ByteString bs1(kTest1, sizeof(kTest1));
  ByteString fragment(kTest1 + 3, 4);
  EXPECT_TRUE(fragment.Equals(bs1.GetSubstring(3, 4)));
  const int kMargin = sizeof(kTest1) - 3;
  ByteString end_fragment(kTest1 + kMargin, sizeof(kTest1) - kMargin);
  EXPECT_TRUE(end_fragment.Equals(bs1.GetSubstring(kMargin, sizeof(kTest1))));

  // Verify that the ByteString correctly handles accessing a substring
  // outside the range of the ByteString.
  const size_t kBogusOffset = 10;
  EXPECT_TRUE(bs1.GetSubstring(sizeof(kTest1), kBogusOffset).IsEmpty());
}

TEST_F(ByteStringTest, UInt32) {
  ByteString bs1 = ByteString::CreateFromNetUInt32(kTest2Uint32);
  uint32_t val;

  EXPECT_EQ(4, bs1.GetLength());
  ASSERT_NE(nullptr, bs1.GetData());
  EXPECT_TRUE(bs1.ConvertToNetUInt32(&val));
  EXPECT_EQ(kTest2Uint32, val);
  EXPECT_FALSE(bs1.IsZero());

  ByteString bs2(kTest2, sizeof(kTest2));
  EXPECT_TRUE(bs1.Equals(bs2));
  EXPECT_TRUE(bs2.ConvertToNetUInt32(&val));
  EXPECT_EQ(kTest2Uint32, val);

  ByteString bs3 = ByteString::CreateFromCPUUInt32(0x1020304);
  EXPECT_EQ(4, bs1.GetLength());
  ASSERT_NE(nullptr, bs3.GetData());
  EXPECT_TRUE(bs3.ConvertToCPUUInt32(&val));
  EXPECT_EQ(0x1020304, val);
  EXPECT_FALSE(bs3.IsZero());

#if __BYTE_ORDER == __LITTLE_ENDIAN
  EXPECT_FALSE(bs1.Equals(bs3));
#else
  EXPECT_TRUE(bs1.Equals(bs3));
#endif
}

TEST_F(ByteStringTest, Resize) {
  ByteString bs(kTest2, sizeof(kTest2));

  const size_t kSizeExtension = 10;
  bs.Resize(sizeof(kTest2) + kSizeExtension);
  EXPECT_EQ(sizeof(kTest2) + kSizeExtension, bs.GetLength());
  ASSERT_NE(nullptr, bs.GetData());
  EXPECT_EQ(0, memcmp(bs.GetData(), kTest2, sizeof(kTest2)));
  for (size_t i = sizeof(kTest2); i < sizeof(kTest2) + kSizeExtension; ++i) {
    EXPECT_EQ(0, bs.GetData()[i]);
  }

  const size_t kSizeReduction = 2;
  bs.Resize(sizeof(kTest2) - kSizeReduction);
  EXPECT_EQ(sizeof(kTest2) - kSizeReduction, bs.GetLength());
  EXPECT_EQ(0, memcmp(bs.GetData(), kTest2, sizeof(kTest2) - kSizeReduction));
}

TEST_F(ByteStringTest, HexEncode) {
  ByteString bs(kTest2, sizeof(kTest2));
  EXPECT_EQ(kTest2HexString, bs.HexEncode());
}

TEST_F(ByteStringTest, BitwiseAnd) {
  ByteString bs1(kTest1, sizeof(kTest1));

  // Unequal sizes should fail and not modify bs1.
  EXPECT_FALSE(bs1.BitwiseAnd(ByteString(kTest2, sizeof(kTest2))));
  EXPECT_TRUE(bs1.Equals(ByteString(kTest1, sizeof(kTest1))));

  const ByteString bs6(kTest6, sizeof(kTest6));
  EXPECT_TRUE(bs1.BitwiseAnd(bs6));

  const unsigned char kAndResult[] = { 0, 0, 2, 2, 4, 4, 2, 2, 0, 0 };
  const ByteString expected_result(kAndResult, sizeof(kAndResult));
  EXPECT_TRUE(bs1.Equals(expected_result));
}

TEST_F(ByteStringTest, BitwiseOr) {
  ByteString bs1(kTest1, sizeof(kTest1));

  // Unequal sizes should fail and not modify bs1.
  EXPECT_FALSE(bs1.BitwiseOr(ByteString(kTest2, sizeof(kTest2))));
  EXPECT_TRUE(bs1.Equals(ByteString(kTest1, sizeof(kTest1))));

  const ByteString bs6(kTest6, sizeof(kTest6));
  EXPECT_TRUE(bs1.BitwiseOr(bs6));

  const unsigned char kOrResult[] = { 9, 9, 7, 7, 5, 5, 7, 7, 9, 9 };
  const ByteString expected_result(kOrResult, sizeof(kOrResult));
  EXPECT_TRUE(bs1.Equals(expected_result));
}

TEST_F(ByteStringTest, BitwiseInvert) {
  ByteString bs(kTest1, sizeof(kTest1));
  ByteString invert;
  for (size_t i = 0; i < sizeof(kTest1); i++) {
    unsigned char val = kTest1[i] ^ 0xff;
    invert.Append(ByteString(&val, 1));
  }
  bs.BitwiseInvert();
  EXPECT_TRUE(bs.Equals(invert));
}

TEST_F(ByteStringTest, CreateFromHexString) {
  ByteString bs = ByteString::CreateFromHexString("");
  EXPECT_TRUE(bs.IsEmpty());

  ByteString bs1 = ByteString::CreateFromHexString("0");
  EXPECT_TRUE(bs1.IsEmpty());

  ByteString bs2 = ByteString::CreateFromHexString("0y");
  EXPECT_TRUE(bs2.IsEmpty());

  ByteString bs3 = ByteString::CreateFromHexString("ab");
  EXPECT_EQ(1, bs3.GetLength());
  EXPECT_EQ(0xab, bs3.GetData()[0]);

  ByteString bs4 = ByteString::CreateFromHexString(kTest1HexString);
  EXPECT_EQ(kTest1HexString, bs4.HexEncode());
}

TEST_F(ByteStringTest, ConvertFromNetToCPUUInt32Array) {
  ByteString bs1;
  EXPECT_TRUE(bs1.ConvertFromNetToCPUUInt32Array());
  EXPECT_TRUE(bs1.IsEmpty());

  // Conversion should fail when the length of ByteString is not a
  // multiple of 4.
  ByteString bs2(kTest1, sizeof(kTest1));
  EXPECT_EQ(kTest1HexString, bs2.HexEncode());
  EXPECT_FALSE(bs2.ConvertFromNetToCPUUInt32Array());
  EXPECT_EQ(kTest1HexString, bs2.HexEncode());

  // Conversion should succeed when the length of ByteString is a
  // multiple of 4.
  bs2.Resize(8);
  EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode());
  EXPECT_TRUE(bs2.ConvertFromNetToCPUUInt32Array());
  if (IsCPUSameAsNetOrder()) {
    EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode());
  } else {
    EXPECT_EQ(kTest1HexSubstringReordered, bs2.HexEncode());
  }
}

TEST_F(ByteStringTest, ConvertFromCPUToNetUInt32Array) {
  ByteString bs1;
  EXPECT_TRUE(bs1.ConvertFromCPUToNetUInt32Array());
  EXPECT_TRUE(bs1.IsEmpty());

  // Conversion should fail when the length of ByteString is not a
  // multiple of 4.
  ByteString bs2(kTest1, sizeof(kTest1));
  EXPECT_EQ(kTest1HexString, bs2.HexEncode());
  EXPECT_FALSE(bs2.ConvertFromCPUToNetUInt32Array());
  EXPECT_EQ(kTest1HexString, bs2.HexEncode());

  // Conversion should succeed when the length of ByteString is a
  // multiple of 4.
  bs2.Resize(8);
  EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode());
  EXPECT_TRUE(bs2.ConvertFromCPUToNetUInt32Array());
  if (IsCPUSameAsNetOrder()) {
    EXPECT_EQ(kTest1HexSubstring, bs2.HexEncode());
  } else {
    EXPECT_EQ(kTest1HexSubstringReordered, bs2.HexEncode());
  }
}

TEST_F(ByteStringTest, LessThan) {
  ByteString bs1(kTest1, sizeof(kTest1));
  ByteString bs2(kTest2, sizeof(kTest2));
  ByteString bs3(kTest3, sizeof(kTest3));
  ByteString bs5(kTest5, sizeof(kTest5));

  // bs2 is shorter, but the first four bytes of bs1 are less than those in bs2.
  EXPECT_TRUE(ByteString::IsLessThan(bs1, bs2));

  // bs2 and bs3 are the same length, but bs3 has less byte values.
  EXPECT_TRUE(ByteString::IsLessThan(bs3, bs2));

  // bs3 is shorter than bs1 and the first four bytes of bs3 are less than
  // the first four bytes of bs1.
  EXPECT_TRUE(ByteString::IsLessThan(bs3, bs1));

  // The first three bytes of bs5 are equal to the first three bytes of bs2,
  // but bs5 is shorter than bs2.
  EXPECT_TRUE(ByteString::IsLessThan(bs5, bs2));

  // A Bytestring is not less than another identical one.
  EXPECT_FALSE(ByteString::IsLessThan(bs5, bs5));
}

TEST_F(ByteStringTest, LessThanOperator) {
  ByteString bs1(kTest1, sizeof(kTest1));
  ByteString bs2(kTest2, sizeof(kTest2));
  ByteString bs3(kTest3, sizeof(kTest3));
  ByteString bs5(kTest5, sizeof(kTest5));

  // This testcase mirror the LessThan testcase.
  EXPECT_LT(bs1, bs2);
  EXPECT_FALSE(bs2 < bs1);

  EXPECT_LT(bs1, bs2);
  EXPECT_FALSE(bs2 < bs3);

  EXPECT_LT(bs1, bs2);
  EXPECT_FALSE(bs1 < bs3);

  EXPECT_LT(bs1, bs2);
  EXPECT_FALSE(bs2 < bs5);

  EXPECT_FALSE(bs5 < bs5);
}

TEST_F(ByteStringTest, MoveConstructor) {
  const ByteString const_data(kTest1, sizeof(kTest1));
  ByteString source_data(kTest1, sizeof(kTest1));
  EXPECT_EQ(const_data, source_data);

  const ByteString dest_data(std::move(source_data));
  EXPECT_TRUE(source_data.IsEmpty());
  EXPECT_EQ(const_data, dest_data);
}

TEST_F(ByteStringTest, MoveAssignmentOperator) {
  const ByteString const_data(kTest1, sizeof(kTest1));
  ByteString source_data(kTest1, sizeof(kTest1));
  ByteString dest_data(kTest2, sizeof(kTest2));

  EXPECT_EQ(const_data, source_data);
  EXPECT_FALSE(const_data.Equals(dest_data));

  dest_data = std::move(source_data);
  EXPECT_TRUE(source_data.IsEmpty());
  EXPECT_EQ(const_data, dest_data);
}

}  // namespace shill