vendor_libs/test_vendor_lib/test/l2cap_test.cc

/******************************************************************************
 *
 *  Copyright 2017 Google, Inc.
 *
 *  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 "hci_packet.h"
#include "l2cap_packet.h"
#include "l2cap_test_packets.h"

#include <gtest/gtest.h>
#include <memory>

using std::shared_ptr;
using std::vector;

namespace test_vendor_lib {

class TestPacket : public HciPacket {
 public:
  TestPacket(const std::vector<uint8_t>& packet) {
    complete_packet_ = packet;
  }
  TestPacket() = default;

 private:
  std::vector<uint8_t> complete_packet_;
  size_t get_length() {
    return complete_packet_.size();
  }
  uint8_t& get_at_index(size_t index) {
    return complete_packet_[index];
  }
};

class L2capTest : public ::testing::Test {
 public:
  std::shared_ptr<L2capSdu> update_fcs(vector<uint8_t> sdu) {
    sdu.resize(sdu.size() - 2);

    return L2capSdu::L2capSduBuilder(sdu);
  }

  void compare_packets(shared_ptr<HciPacket> expected, shared_ptr<HciPacket> received) {
    Iterator expected_begin = expected->get_begin();
    Iterator expected_end = expected->get_end();

    Iterator received_begin = received->get_begin();
    Iterator received_end = received->get_end();

    ASSERT_EQ(expected_end - expected_begin, received_end - received_begin);

    while (expected_begin < expected_end) {
      ASSERT_EQ(*expected_begin, *received_begin);
      expected_begin++;
      received_begin++;
    }
  }
};

TEST_F(L2capTest, assembleGoodPackets) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 1: Pass correct packets.
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  shared_ptr<L2capPacket> test_1 = L2capPacket::assemble(test_packet);
  ASSERT_NE(test_1, nullptr);

  shared_ptr<TestPacket> expected(new TestPacket(good_l2cap_packet));

  compare_packets(expected, test_1);

  test_packet.clear();

  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  test_1 = L2capPacket::assemble(test_packet);
  ASSERT_NE(test_1, nullptr);

  expected.reset(new TestPacket(complete_l2cap_packet));
  compare_packets(expected, test_1);

  test_packet.clear();
}

TEST_F(L2capTest, assembleOutofOrderPackets) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 2: Pass out of order packets.
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  shared_ptr<L2capPacket> test_2 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_2, nullptr);

  test_packet.clear();

  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  test_2 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_2, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleBadControlBytes) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 3: Pass packets missing the finished control bytes.
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));

  shared_ptr<L2capPacket> test_3 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_3, nullptr);

  test_packet.clear();

  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));

  test_3 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_3, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleBadFCS) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 4: Pass packets with incorrect frame check sequences.
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  good_sdu[1][good_sdu[1].size() - 1]++;
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  good_sdu[1][good_sdu[1].size() - 1]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  shared_ptr<L2capPacket> test_4 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_4, nullptr);

  test_packet.clear();

  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  l2cap_test_packet_5[l2cap_test_packet_5.size() - 1]++;
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  l2cap_test_packet_5[l2cap_test_packet_5.size() - 1]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  test_4 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_4, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleEmptyPayload) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 5: Pass a packet with an empty payload.
  test_packet.push_back(L2capSdu::L2capSduConstructor(empty_sdu_payload[0]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(empty_sdu_payload[1]));

  shared_ptr<L2capPacket> test_5 = L2capPacket::assemble(test_packet);
  ASSERT_NE(test_5, nullptr);

  shared_ptr<TestPacket> expected(new TestPacket(empty_l2cap_payload));
  compare_packets(expected, test_5);

  test_packet.clear();
}

TEST_F(L2capTest, assembleAllStartingControlError) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 6: Pass a SDU with all the control bytes set to as the starting bytes.
  test_packet.push_back(L2capSdu::L2capSduConstructor(all_first_packet[0]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(all_first_packet[1]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(all_first_packet[2]));

  shared_ptr<L2capPacket> test_6 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_6, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleBadCID) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 7: Pass SDUs with mixed channel ids.
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  good_sdu[1][2]++;
  test_packet.push_back(update_fcs(good_sdu[1]));
  good_sdu[1][2]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  shared_ptr<L2capPacket> test_7 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_7, nullptr);

  test_packet.clear();

  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  l2cap_test_packet_2[2]++;
  test_packet.push_back((update_fcs(l2cap_test_packet_2)));
  l2cap_test_packet_2[2]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  l2cap_test_packet_5[2]++;
  test_packet.push_back((update_fcs(l2cap_test_packet_5)));
  l2cap_test_packet_5[2]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  l2cap_test_packet_8[2]--;
  test_packet.push_back((update_fcs(l2cap_test_packet_8)));
  l2cap_test_packet_8[2]++;
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  test_7 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_7, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleUnsegmentedSDU) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 8: Pass a complete l2cap packet.
  test_packet.push_back(L2capSdu::L2capSduConstructor(one_sdu[0]));

  shared_ptr<L2capPacket> test_8 = L2capPacket::assemble(test_packet);
  EXPECT_NE(test_8, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleBadTxSeq) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 9: Pass SDUs with incorrect TxSeq.
  good_sdu[0][4] += 4;
  test_packet.push_back((update_fcs(good_sdu[0])));
  good_sdu[0][4] -= 4;
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  shared_ptr<L2capPacket> test_9 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_9, nullptr);

  test_packet.clear();
}

TEST_F(L2capTest, assembleBadTotalSDULength) {
  vector<std::shared_ptr<L2capSdu> > test_packet;

  // Test 10: Pass SDUs with an incorrect total SDU length
  good_sdu[0][7]++;
  test_packet.push_back((update_fcs(good_sdu[0])));
  good_sdu[0][7]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  test_packet.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  shared_ptr<L2capPacket> test_10 = L2capPacket::assemble(test_packet);
  EXPECT_EQ(test_10, nullptr);

  test_packet.clear();

  l2cap_test_packet_1[6]++;
  test_packet.push_back((update_fcs(l2cap_test_packet_1)));
  l2cap_test_packet_1[6]--;
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));
  test_packet.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  test_10 = L2capPacket::assemble(test_packet);

  EXPECT_EQ(test_10, nullptr);

  test_packet.clear();
}

// Begin Fragment Test1
TEST_F(L2capTest, fragmentSmallSegmentTest) {
  std::vector<std::shared_ptr<L2capSdu> > sdu;
  std::shared_ptr<L2capPacket> l2cap_expected;
  std::shared_ptr<L2capPacket> l2cap_received;

  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  l2cap_expected = L2capPacket::assemble(sdu);

  sdu.clear();

  // Test1: Small segments
  sdu = l2cap_expected->fragment(16, 0x02, 0x41);

  l2cap_received = L2capPacket::assemble(sdu);
  ASSERT_NE(l2cap_received, nullptr) << "packet reassembly failed after fragment" << std::endl
                                     << "Test1: Small Segment request" << std::endl
                                     << "sdu used: good_sdu" << std::endl
                                     << "function call: fragment(16, 0x02, 0x41)" << std::endl;

  compare_packets(l2cap_expected, l2cap_received);

  sdu.clear();
  l2cap_expected.reset();
  l2cap_received.reset();
}  // End Fragment Test1

// Begin Fragment Test2
TEST_F(L2capTest, fragmentLargeSegmentTest) {
  std::vector<std::shared_ptr<L2capSdu> > sdu;
  std::shared_ptr<L2capPacket> l2cap_expected;
  std::shared_ptr<L2capPacket> l2cap_received;

  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  l2cap_expected = L2capPacket::assemble(sdu);

  sdu.clear();

  // Test2: Large Segments
  sdu = l2cap_expected->fragment(1024, 0x02, 0x41);

  l2cap_received = L2capPacket::assemble(sdu);
  ASSERT_NE(l2cap_received, nullptr) << "packet reassembly failed after fragment" << std::endl
                                     << "Test2: Large Segment request" << std::endl
                                     << "sdu used: l2cap_test_packet[1-9]" << std::endl
                                     << "function call: fragment(1024, 0x02, 0x41)" << std::endl;

  compare_packets(l2cap_expected, l2cap_received);

  sdu.clear();
  l2cap_expected.reset();
  l2cap_received.reset();
}  // End Fragment Test2

// Begin Fragment Test3
TEST_F(L2capTest, fragmentTxSeqTest) {
  std::vector<std::shared_ptr<L2capSdu> > sdu;
  std::shared_ptr<L2capPacket> l2cap_expected;
  std::shared_ptr<L2capPacket> l2cap_received;

  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  l2cap_expected = L2capPacket::assemble(sdu);

  sdu.clear();

  // Test3: Non-zero starting TxSeq
  sdu = l2cap_expected->fragment(24, 0x08, 0x41);

  l2cap_received = L2capPacket::assemble(sdu);
  ASSERT_NE(l2cap_received, nullptr) << "packet reassembly failed after fragment" << std::endl
                                     << "Test3: Non-zero starting TxSeq" << std::endl
                                     << "sdu used: good_sdu" << std::endl
                                     << "function call: fragment(24, 0x08, 0x41)" << std::endl;

  compare_packets(l2cap_expected, l2cap_received);

  sdu.clear();
  l2cap_expected.reset();
  l2cap_received.reset();
}  // End Fragment Test3

// Begin Fragment Test4
TEST_F(L2capTest, fragmentPayloadTest) {
  std::vector<std::shared_ptr<L2capSdu> > sdu;
  std::shared_ptr<L2capPacket> l2cap_expected;
  std::shared_ptr<L2capPacket> l2cap_received;

  sdu.push_back(L2capSdu::L2capSduConstructor(empty_sdu_payload[0]));
  sdu.push_back(L2capSdu::L2capSduConstructor(empty_sdu_payload[1]));

  l2cap_expected = L2capPacket::assemble(sdu);

  sdu.clear();

  // Test4: Packet with no payload
  sdu = l2cap_expected->fragment(16, 0x02, 0x41);

  l2cap_received = L2capPacket::assemble(sdu);
  ASSERT_NE(l2cap_received, nullptr) << "packet reassembly failed after fragment" << std::endl
                                     << "Test4: Packet with no payload" << std::endl
                                     << "sdu used: empty_sdu_payload" << std::endl
                                     << "function call: fragment(16, 0x02, 0x41)" << std::endl;

  compare_packets(l2cap_expected, l2cap_received);

  sdu.clear();
  l2cap_expected.reset();
  l2cap_received.reset();
}  // End Fragment Test4

// Begin Fragment Test5
TEST_F(L2capTest, fragmentSegmentSizeTest) {
  std::vector<std::shared_ptr<L2capSdu> > sdu;
  std::shared_ptr<L2capPacket> l2cap_expected;
  std::shared_ptr<L2capPacket> l2cap_received;

  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[0]));
  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[1]));
  sdu.push_back(L2capSdu::L2capSduConstructor(good_sdu[2]));

  l2cap_expected = L2capPacket::assemble(sdu);

  sdu.clear();

  // Test5: Larger segment size than packet size
  sdu = l2cap_expected->fragment(256, 0x02, 0x41);

  l2cap_received = L2capPacket::assemble(sdu);
  ASSERT_NE(l2cap_received, nullptr) << "packet reassembly failed after fragment" << std::endl
                                     << "Test5: Segment size > Payload" << std::endl
                                     << "sdu used: good_sdu" << std::endl
                                     << "function call: fragment(256, 0x02, 0x41)" << std::endl;

  compare_packets(l2cap_expected, l2cap_received);

  sdu.clear();
  l2cap_expected.reset();
  l2cap_received.reset();
}  // End Fragment Test5

// Begin Fragment Test6
TEST_F(L2capTest, fragmentSegmentSizeTest2) {
  std::vector<std::shared_ptr<L2capSdu> > sdu;
  std::shared_ptr<L2capPacket> l2cap_expected;
  std::shared_ptr<L2capPacket> l2cap_received;

  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_1));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_2));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_3));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_4));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_5));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_6));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_7));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_8));
  sdu.push_back(L2capSdu::L2capSduConstructor(l2cap_test_packet_9));

  l2cap_expected = L2capPacket::assemble(sdu);
  sdu.clear();

  // Test6: Small segment size on large packet.
  sdu = l2cap_expected->fragment(512, 0x02, 0x41);

  l2cap_received = L2capPacket::assemble(sdu);
  ASSERT_NE(l2cap_received, nullptr) << "packet reassembly failed after fragment" << std::endl
                                     << "Test6: Small Segment request on large packet" << std::endl
                                     << "sdu used: l2cap_test_packet_[1-9]" << std::endl
                                     << "function call: fragment(64, 0x02, 0x41)" << std::endl;

  compare_packets(l2cap_expected, l2cap_received);

  sdu.clear();
  l2cap_expected.reset();
  l2cap_received.reset();
}  // End Fragment Test6

}  // namespace test_vendor_lib