/*
 * Copyright 2018 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 <gtest/gtest.h>
#include <memory>

#include "packet.h"
#include "packet_test_common.h"
#include "test_packets.h"

namespace bluetooth {

using pair = std::pair<size_t, size_t>;

class IteratorTest
    : public ::testing::TestWithParam<std::pair<size_t, size_t>> {
 public:
  std::shared_ptr<TestPacket> GetTestPacket() {
    auto bounds = GetParam();
    auto lower_bound = bounds.first;
    auto upper_bound = bounds.second;

    return TestPacket::Make(test_l2cap_data, lower_bound, upper_bound);
  }

  size_t GetTestPacketLength() { return GetParam().second - GetParam().first; }

  size_t GetLowerBound() { return GetParam().first; }

  size_t GetUpperBound() { return GetParam().second; }
};

INSTANTIATE_TEST_CASE_P(IteratorParameterTest, IteratorTest,
                        ::testing::Values(pair(0, test_l2cap_data.size()),
                                          pair(3, test_l2cap_data.size() - 2)));

TEST_F(IteratorTest, iteratorCreateDeathTest) {
  auto packet =
      TestPacket::Make(test_l2cap_data, 3, test_l2cap_data.size() - 2);
  ASSERT_DEATH(Iterator(packet, 0), "index_ >= packet->packet_start_index_");
  ASSERT_DEATH(Iterator(packet, test_l2cap_data.size()),
               "index_ <= packet->packet_end_index_");
}

TEST_F(IteratorTest, extractTest) {
  auto packet = TestPacket::Make(test_l2cap_data);
  Iterator general_case = packet->begin();

  ASSERT_EQ(0x02u, general_case.extract<uint8_t>());
  ASSERT_EQ(0x2edcu, general_case.extract<uint16_t>());
  ASSERT_EQ(0x00620066u, general_case.extract<uint32_t>());
  ASSERT_EQ(0x00010000000a0013u, general_case.extract<uint64_t>());
}

TEST_F(IteratorTest, extractBETest) {
  auto packet = TestPacket::Make(test_l2cap_data);
  Iterator general_case = packet->begin();

  ASSERT_EQ(0x02u, general_case.extractBE<uint8_t>());
  ASSERT_EQ(0xdc2eu, general_case.extractBE<uint16_t>());
  ASSERT_EQ(0x66006200u, general_case.extractBE<uint32_t>());
  ASSERT_EQ(0x13000a0000000100u, general_case.extractBE<uint64_t>());
}

TEST_P(IteratorTest, payloadBoundsTest) {
  auto packet = GetTestPacket();
  ASSERT_EQ(static_cast<size_t>(packet->end() - packet->begin()),
            GetTestPacketLength());

  auto it = packet->begin();
  for (size_t i = 0; i < GetTestPacketLength(); i++) {
    ASSERT_EQ(test_l2cap_data[i + GetLowerBound()], *it++);
  }
}

TEST_P(IteratorTest, extractBoundsDeathTest) {
  auto packet = GetTestPacket();
  Iterator bounds_test = packet->end();
  ASSERT_DEATH(bounds_test.extract<uint8_t>(),
               "index_ != packet_->packet_end_index_");
  ASSERT_DEATH(bounds_test.extract<uint16_t>(),
               "index_ != packet_->packet_end_index_");
  ASSERT_DEATH(bounds_test.extract<uint32_t>(),
               "index_ != packet_->packet_end_index_");
  ASSERT_DEATH(bounds_test.extract<uint64_t>(),
               "index_ != packet_->packet_end_index_");
}

TEST_P(IteratorTest, extractBEBoundsDeathTest) {
  auto packet = GetTestPacket();
  Iterator bounds_test = packet->end();
  ASSERT_DEATH(bounds_test.extractBE<uint8_t>(),
               "index_ != packet_->packet_end_index_");
  ASSERT_DEATH(bounds_test.extractBE<uint16_t>(),
               "index_ != packet_->packet_end_index_");
  ASSERT_DEATH(bounds_test.extractBE<uint32_t>(),
               "index_ != packet_->packet_end_index_");
  ASSERT_DEATH(bounds_test.extractBE<uint64_t>(),
               "index_ != packet_->packet_end_index_");
}

TEST_P(IteratorTest, dereferenceDeathTest) {
  auto packet = GetTestPacket();
  Iterator dereference_test = packet->end();

  ASSERT_EQ((*packet)[GetTestPacketLength() - 1],
            *(dereference_test - static_cast<size_t>(1)));
  ASSERT_DEATH(*dereference_test, "index_ != packet_->packet_end_index_");
}

TEST_P(IteratorTest, plusEqTest) {
  auto packet = GetTestPacket();
  Iterator plus_eq = packet->begin();
  for (size_t i = 0; i < GetTestPacketLength(); i += 2) {
    ASSERT_EQ(test_l2cap_data[i + GetLowerBound()], *plus_eq)
        << "+= test: Dereferenced iterator does not equal expected at index "
        << i;
    plus_eq += 2;
  }

  ASSERT_EQ(plus_eq, packet->end());
}

TEST_P(IteratorTest, preIncrementTest) {
  auto packet = GetTestPacket();
  Iterator plus_plus = packet->begin();
  for (size_t i = 0; i < GetTestPacketLength() - 1; i++) {
    ASSERT_EQ(test_l2cap_data[i + GetLowerBound() + 1], *(++plus_plus))
        << "Pre-increment test: Dereferenced iterator does not equal expected "
        << "at index " << i;
  }
}

TEST_P(IteratorTest, postIncrementTest) {
  auto packet = GetTestPacket();
  Iterator plus_plus = packet->begin();
  for (size_t i = 0; i < GetTestPacketLength(); i++) {
    ASSERT_EQ(test_l2cap_data[i + GetLowerBound()], *(plus_plus++))
        << "Post-increment test: Dereferenced iterator does not equal expected "
        << "at index " << i;
  }
}

TEST_P(IteratorTest, additionTest) {
  auto packet = GetTestPacket();
  Iterator plus = packet->begin();
  for (size_t i = 0; i < GetTestPacketLength(); i++) {
    ASSERT_EQ(test_l2cap_data[i + GetLowerBound()], *plus)
        << "+ test: Dereferenced iterator does not equal expected at index "
        << i;
    plus = plus + static_cast<size_t>(1);
  }
}

TEST_P(IteratorTest, minusEqTest) {
  auto packet = GetTestPacket();
  Iterator minus_eq = packet->end();
  minus_eq -= 1;
  for (int i = GetTestPacketLength() - 1; i > 0; i -= 2) {
    ASSERT_EQ(test_l2cap_data[static_cast<size_t>(i) + GetLowerBound()],
              *minus_eq)
        << "-= test: Dereferenced iterator does not equal expected at index "
        << i;
    minus_eq -= 2;
  }
}

TEST_P(IteratorTest, preDecrementTest) {
  auto packet = GetTestPacket();
  Iterator minus_minus = packet->end();
  for (int i = GetTestPacketLength(); i > 0; i--) {
    ASSERT_EQ(test_l2cap_data[static_cast<size_t>(i) + GetLowerBound() - 1],
              *(--minus_minus))
        << "Pre-decrement test: Dereferenced iterator does not equal expected "
        << "at index " << i;
  }
}

TEST_P(IteratorTest, postDecrementTest) {
  auto packet = GetTestPacket();
  Iterator minus_minus = packet->end();
  minus_minus--;
  for (int i = GetTestPacketLength() - 1; i > 0; i--) {
    ASSERT_EQ(test_l2cap_data[static_cast<size_t>(i) + GetLowerBound()],
              *(minus_minus--))
        << "Post-decrement test: Dereferenced iterator does not equal expected "
        << "at index " << i;
  }
}

TEST_P(IteratorTest, subtractionTest) {
  auto packet = GetTestPacket();
  Iterator minus = packet->end();
  minus = minus - static_cast<size_t>(1);
  for (int i = GetTestPacketLength() - 1; i > 0; i--) {
    ASSERT_EQ(test_l2cap_data[static_cast<size_t>(i) + GetLowerBound()], *minus)
        << "- test: Dereferenced iterator does not equal expected at index "
        << i;
    minus = minus - static_cast<size_t>(1);
  }
}

TEST_P(IteratorTest, plusEqBoundsTest) {
  auto packet = GetTestPacket();
  Iterator plus_eq = packet->end();
  for (size_t i = 0; i < 100; i++) {
    plus_eq += i;
    ASSERT_EQ(packet->end(), plus_eq)
        << "+= test: Iterator exceeded the upper bound set by get_length()";
  }
}

TEST_P(IteratorTest, preIncrementBoundsTest) {
  auto packet = GetTestPacket();
  Iterator plus_plus = packet->end();
  plus_plus--;
  for (size_t i = 0; i < 100; i++) {
    ASSERT_EQ(packet->end(), ++plus_plus)
        << "Pre-increment test: Iterator exceeded the upper bound set "
           "by get_length()";
  }
}

TEST_P(IteratorTest, postIncrementBoundsTest) {
  auto packet = GetTestPacket();
  Iterator plus_plus = packet->end();
  for (size_t i = 0; i < 100; i++) {
    ASSERT_EQ(packet->end(), plus_plus++)
        << "Post-increment test: Iterator exceeded the upper bound set "
           "by get_length()";
  }
}

TEST_P(IteratorTest, additionBoundsTest) {
  auto packet = GetTestPacket();
  Iterator plus = packet->end();
  for (size_t i = 0; i < 100; i++) {
    plus = plus + static_cast<size_t>(i);
    ASSERT_EQ(packet->end(), plus)
        << "+ test: Iterator exceeded the upper bound set by get_length()";
  }
}

TEST_P(IteratorTest, minusEqBoundsTest) {
  auto packet = GetTestPacket();
  Iterator minus_eq = packet->begin();
  for (size_t i = 0; i < 100; i++) {
    minus_eq -= i;
    ASSERT_EQ(test_l2cap_data[GetLowerBound()], *minus_eq)
        << "-= test: Iterator is less than the lower bound set by "
           "packet->begin()";
  }
}

TEST_P(IteratorTest, preDecrementBoundsTest) {
  auto packet = GetTestPacket();
  Iterator minus_minus = packet->begin();
  for (size_t i = 0; i < 100; i++) {
    ASSERT_EQ(test_l2cap_data[GetLowerBound()], *(--minus_minus))
        << "Pre-decrement test: Iterator is less than the lower bound set by "
           "packet->begin()";
  }
}

TEST_P(IteratorTest, postDecrementBoundsTest) {
  auto packet = GetTestPacket();
  Iterator minus_minus = packet->begin();
  for (size_t i = 0; i < 100; i++) {
    ASSERT_EQ(test_l2cap_data[GetLowerBound()], *(minus_minus--))
        << "Post-decrement test: Iterator is less than the lower bound set by "
           "packet->begin()";
  }
}

TEST_P(IteratorTest, subtractionBoundsTest) {
  auto packet = GetTestPacket();
  Iterator minus = packet->begin();
  for (size_t i = 0; i < 100; i++) {
    minus = minus - static_cast<size_t>(i);
    ASSERT_EQ(test_l2cap_data[GetLowerBound()], *minus)
        << "- test: Iterator is less than the lower bound set "
           "by packet->begin()";
  }
}

}  // namespace bluetooth