Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d57d07d4 authored by johnshamoon's avatar johnshamoon Committed by John Shamoon
Browse files

test_vendor: Add Iterator tests 

Add Iterator tests to check that the overloaded operators and bounded iterators
are implemented correctly.

Test: Run the unit tests:
out/host/linux-x86/nativetest64/test-vendor_test_host/\
test-vendor_test_host --gtest_filter=IteratorTest.*
Change-Id: I6402cc36fe6818fa972524ac20aed526128a8553
parent 1b687818

system/vendor_libs/test_vendor_lib/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -71,6 +71,7 @@ cc_test_host { 
        "test/async_manager_unittest.cc",

        "test/bt_address_unittest.cc",

        "test/packet_stream_unittest.cc",

        "test/iterator_test.cc",

        "test/l2cap_test.cc",

        "test/l2cap_sdu_test.cc",

    ],

system/vendor_libs/test_vendor_lib/test/iterator_test.cc

0 → 100644
+192 −0
Original line number Diff line number Diff line 
#include "hci_packet.h"

#include "l2cap_test_packets.h"



#include <gtest/gtest.h>

#include <memory>



using std::unique_ptr;

using std::vector;

namespace test_vendor_lib {



class TestPacket : public HciPacket {

 public:

  static std::shared_ptr<TestPacket> make_new_packet(vector<uint8_t> v) {

    return std::shared_ptr<TestPacket>(new TestPacket(v));

  }

  size_t get_length() { return test_vector_.size(); }

  uint8_t& get_at_index(size_t index) { return test_vector_[index]; }



 private:

  TestPacket(vector<uint8_t> v) { test_vector_ = v; }

  vector<uint8_t> test_vector_;

};



class IteratorTest : public ::testing::Test {

 public:

  IteratorTest() = default;

  ~IteratorTest() = default;



  void SetUp() { packet = TestPacket::make_new_packet(complete_l2cap_packet); }



  void TearDown() { packet.reset(); }



  std::shared_ptr<TestPacket> packet;

};



TEST_F(IteratorTest, plusEqTest) {

  Iterator plus_eq = packet->get_begin();

  for (size_t i = 0; i < complete_l2cap_packet.size(); i += 2) {

    ASSERT_EQ(complete_l2cap_packet[i], *plus_eq)

        << "+= test: Dereferenced iterator does not equal expected at index "

        << i;

    plus_eq += 2;

  }

}



TEST_F(IteratorTest, preIncrementTest) {

  Iterator plus_plus = packet->get_begin();

  for (size_t i = 0; i < complete_l2cap_packet.size(); i++) {

    ASSERT_EQ(complete_l2cap_packet[i + 1], *(++plus_plus))

        << "Pre-increment test: Dereferenced iterator does not equal expected "

        << "at index " << i;

  }

}



TEST_F(IteratorTest, postIncrementTest) {

  Iterator plus_plus = packet->get_begin();

  for (size_t i = 0; i < complete_l2cap_packet.size(); i++) {

    ASSERT_EQ(complete_l2cap_packet[i], *(plus_plus++))

        << "Post-increment test: Dereferenced iterator does not equal expected "

        << "at index " << i;

  }

}



TEST_F(IteratorTest, additionTest) {

  Iterator plus = packet->get_begin();

  for (size_t i = 0; i < complete_l2cap_packet.size(); i++) {

    ASSERT_EQ(complete_l2cap_packet[i], *plus)

        << "+ test: Dereferenced iterator does not equal expected at index "

        << i;

    plus = plus + static_cast<size_t>(1);

  }

}



TEST_F(IteratorTest, minusEqTest) {

  Iterator minus_eq = packet->get_end();

  minus_eq -= 1;

  for (size_t i = complete_l2cap_packet.size() - 1; i > 0; i -= 2) {

    ASSERT_EQ(complete_l2cap_packet[i], *minus_eq)

        << "-= test: Dereferenced iterator does not equal expected at index "

        << i;

    minus_eq -= 2;

  }

}



TEST_F(IteratorTest, preDecrementTest) {

  Iterator minus_minus = packet->get_end();

  for (size_t i = complete_l2cap_packet.size(); i > 0; i--) {

    ASSERT_EQ(complete_l2cap_packet[i - 1], *(--minus_minus))

        << "Pre-decrement test: Dereferenced iterator does not equal expected "

        << "at index " << i;

  }

}



TEST_F(IteratorTest, postDecrementTest) {

  Iterator minus_minus = packet->get_end();

  minus_minus--;

  for (size_t i = complete_l2cap_packet.size() - 1; i > 0; i--) {

    ASSERT_EQ(complete_l2cap_packet[i], *(minus_minus--))

        << "Post-decrement test: Dereferenced iterator does not equal expected "

        << "at index " << i;

  }

}



TEST_F(IteratorTest, subtractionTest) {

  Iterator minus = packet->get_end();

  minus = minus - static_cast<size_t>(1);

  for (size_t i = complete_l2cap_packet.size() - 1; i > 0; i--) {

    ASSERT_EQ(complete_l2cap_packet[i], *minus)

        << "- test: Dereferenced iterator does not equal expected at index "

        << i;

    minus = minus - static_cast<size_t>(1);

  }

}



TEST_F(IteratorTest, plusEqBoundsTest) {

  Iterator plus_eq = packet->get_end();

  plus_eq--;

  for (size_t i = 0; i < 100; i++) {

    plus_eq += i;

    ASSERT_EQ(packet->get_end(), plus_eq)

        << "+= test: Iterator exceeded the upper bound set by get_length()";

  }

}



TEST_F(IteratorTest, preIncrementBoundsTest) {

  Iterator plus_plus = packet->get_end();

  plus_plus--;

  for (size_t i = 0; i < 100; i++) {

    ASSERT_EQ(packet->get_end(), ++plus_plus)

        << "Pre-increment test: Iterator exceeded the upper bound set "

           "by get_length()";

  }

}



TEST_F(IteratorTest, postIncrementBoundsTest) {

  Iterator plus_plus = packet->get_end();

  plus_plus--;

  for (size_t i = 0; i < 100; i++) {

    ASSERT_EQ(packet->get_end(), plus_plus++)

        << "Post-increment test: Iterator exceeded the upper bound set "

           "by get_length()";

  }

}



TEST_F(IteratorTest, additionBoundsTest) {

  Iterator plus = packet->get_end();

  plus--;

  for (size_t i = 0; i < 100; i++) {

    plus = plus + static_cast<size_t>(i);

    ASSERT_EQ(packet->get_end(), plus)

        << "+ test: Iterator exceeded the upper bound set by get_length()";

  }

}



TEST_F(IteratorTest, minusEqBoundsTest) {

  Iterator minus_eq = packet->get_begin();

  for (size_t i = 0; i < 100; i++) {

    minus_eq -= i;

    ASSERT_EQ(complete_l2cap_packet[0], *minus_eq)

        << "-= test: Iterator is less than the lower bound set by "

           "packet->get_begin()";

  }

}



TEST_F(IteratorTest, preDecrementBoundsTest) {

  Iterator minus_minus = packet->get_begin();

  for (size_t i = 0; i < 100; i++) {

    ASSERT_EQ(complete_l2cap_packet[0], *(--minus_minus))

        << "Pre-decrement test: Iterator is less than the lower bound set by "

           "packet->get_begin()";

  }

}



TEST_F(IteratorTest, postDecrementBoundsTest) {

  Iterator minus_minus = packet->get_begin();

  for (size_t i = 0; i < 100; i++) {

    ASSERT_EQ(complete_l2cap_packet[0], *(minus_minus--))

        << "Post-decrement test: Iterator is less than the lower bound set by "

           "packet->get_begin()";

  }

}



TEST_F(IteratorTest, subtractionBoundsTest) {

  Iterator minus = packet->get_begin();

  for (size_t i = 0; i < 100; i++) {

    minus = minus - static_cast<size_t>(i);

    ASSERT_EQ(complete_l2cap_packet[0], *minus)

        << "- test: Iterator is less than the lower bound set "

           "by packet->get_begin()";

  }

}

};  // namespace test_vendor_lib