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

Commit d33aa944 authored by Myles Watson's avatar Myles Watson
Browse files

test_vendor: Add BtAddress unit tests 



Change-Id: I23d27a1a5c258de330f4eac23d314ef8b9200d2a
Signed-off-by: default avatarMyles Watson <mylesgw@google.com>
parent 9b377dcf

system/vendor_libs/test_vendor_lib/Android.mk

+2 −0
Original line number Diff line number Diff line
@@ -65,12 +65,14 @@ include $(CLEAR_VARS) 


LOCAL_SRC_FILES := \

    src/async_manager.cc \

    src/bt_address.cc \

    src/command_packet.cc \

    src/event_packet.cc \

    src/hci_transport.cc \

    src/packet.cc \

    src/packet_stream.cc \

    test/async_manager_unittest.cc \

    test/bt_address_unittest.cc \

    test/hci_transport_unittest.cc \

    test/packet_stream_unittest.cc

system/vendor_libs/test_vendor_lib/test/bt_address_unittest.cc

0 → 100644
+194 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 *  Copyright (C) 2016 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 <gtest/gtest.h>

#include <string>

#include <vector>

using std::vector;



#include "bt_address.h"



namespace {

const std::string kTestAddr1 = "12:34:56:78:9a:bc";

const std::string kTestAddr2 = "cb:a9:87:65:43:21";

const std::string kTestAddr3 = "cb:a9:56:78:9a:bc";

const std::string kUpperMask = "ff:ff:00:00:00:00";

const std::string kLowerMask = "00:00:ff:ff:ff:ff";

const std::string kZeros = "00:00:00:00:00:00";

const vector<uint8_t> kZeros_octets = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

const vector<uint8_t> kTestAddr1_octets = {0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12};

}



namespace test_vendor_lib {



class BtAddressTest : public ::testing::Test {

 public:

  BtAddressTest() {}

  ~BtAddressTest() {}

};



TEST_F(BtAddressTest, IsValid) {

  EXPECT_FALSE(BtAddress::IsValid(""));

  EXPECT_FALSE(BtAddress::IsValid("000000000000"));

  EXPECT_FALSE(BtAddress::IsValid("00:00:00:00:0000"));

  EXPECT_FALSE(BtAddress::IsValid("00:00:00:00:00:0"));

  EXPECT_FALSE(BtAddress::IsValid("00:00:00:00:00:0;"));

  EXPECT_FALSE(BtAddress::IsValid("00:00:000:00:00:0;"));

  EXPECT_TRUE(BtAddress::IsValid("00:00:00:00:00:00"));

  EXPECT_FALSE(BtAddress::IsValid("aB:cD:eF:Gh:iJ:Kl"));

  EXPECT_TRUE(BtAddress::IsValid(kTestAddr1));

  EXPECT_TRUE(BtAddress::IsValid(kTestAddr2));

  EXPECT_TRUE(BtAddress::IsValid(kTestAddr3));

}



TEST_F(BtAddressTest, test_comparisons) {

  BtAddress btaddr1;

  BtAddress btaddr1_copy;

  BtAddress btaddr2;



  EXPECT_TRUE(btaddr1.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr1_copy.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr2.FromString(kTestAddr2));



  EXPECT_TRUE(btaddr1 == btaddr1_copy);

  EXPECT_FALSE(btaddr1 == btaddr2);



  EXPECT_FALSE(btaddr1 != btaddr1_copy);

  EXPECT_TRUE(btaddr1 != btaddr2);



  EXPECT_FALSE(btaddr1 < btaddr1_copy);

  EXPECT_TRUE(btaddr1 < btaddr2);

  EXPECT_FALSE(btaddr2 < btaddr1);



  EXPECT_FALSE(btaddr1 > btaddr1_copy);

  EXPECT_FALSE(btaddr1 > btaddr2);

  EXPECT_TRUE(btaddr2 > btaddr1);



  EXPECT_TRUE(btaddr1 <= btaddr1_copy);

  EXPECT_TRUE(btaddr1 <= btaddr2);

  EXPECT_FALSE(btaddr2 <= btaddr1);



  EXPECT_TRUE(btaddr1 >= btaddr1_copy);

  EXPECT_FALSE(btaddr1 >= btaddr2);

  EXPECT_TRUE(btaddr2 >= btaddr1);

}



TEST_F(BtAddressTest, test_assignment) {

  BtAddress btaddr1;

  BtAddress btaddr2;

  BtAddress btaddr3;



  EXPECT_TRUE(btaddr1.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr2.FromString(kTestAddr2));

  EXPECT_TRUE(btaddr3.FromString(kTestAddr3));



  EXPECT_TRUE(btaddr1 != btaddr2);

  EXPECT_TRUE(btaddr2 != btaddr3);

  EXPECT_TRUE(btaddr1 != btaddr3);



  btaddr1 = btaddr2;

  EXPECT_TRUE(btaddr1 == btaddr2);

  EXPECT_TRUE(btaddr2 != btaddr3);

  EXPECT_TRUE(btaddr1 != btaddr3);



  btaddr3 = btaddr2;

  EXPECT_TRUE(btaddr1 == btaddr2);

  EXPECT_TRUE(btaddr2 == btaddr3);

  EXPECT_TRUE(btaddr1 == btaddr3);

}



TEST_F(BtAddressTest, test_bitoperations) {

  BtAddress btaddr1;

  BtAddress btaddr2;

  BtAddress btaddr3;

  BtAddress btaddr_lowmask;

  BtAddress btaddr_upmask;



  EXPECT_TRUE(btaddr1.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr2.FromString(kTestAddr2));

  EXPECT_TRUE(btaddr3.FromString(kTestAddr3));

  EXPECT_TRUE(btaddr_lowmask.FromString(kLowerMask));

  EXPECT_TRUE(btaddr_upmask.FromString(kUpperMask));



  EXPECT_TRUE(btaddr1 != btaddr2);

  EXPECT_TRUE(btaddr2 != btaddr3);

  btaddr1 &= btaddr_lowmask;

  btaddr2 &= btaddr_upmask;

  btaddr1 |= btaddr2;

  EXPECT_TRUE(btaddr1 == btaddr3);

}



TEST_F(BtAddressTest, FromString) {

  BtAddress btaddrA;

  BtAddress btaddrB;

  BtAddress btaddrC;

  EXPECT_TRUE(btaddrA.FromString(kTestAddr1));

  EXPECT_TRUE(btaddrA != btaddrB);

  EXPECT_TRUE(btaddrC == btaddrB);

  EXPECT_TRUE(btaddrB.FromString(kTestAddr1));

  EXPECT_TRUE(btaddrC.FromString(kTestAddr1));

  EXPECT_TRUE(btaddrA == btaddrB);

  EXPECT_TRUE(btaddrC == btaddrB);

}



TEST_F(BtAddressTest, FromVector) {

  BtAddress btaddr1;

  EXPECT_TRUE(btaddr1.FromString(kTestAddr1));

  BtAddress btaddrA;

  BtAddress btaddrB;

  EXPECT_TRUE(btaddrA.FromVector(kTestAddr1_octets));

  EXPECT_TRUE(btaddrA != btaddrB);

  EXPECT_TRUE(btaddrB.FromVector(kTestAddr1_octets));

  EXPECT_TRUE(btaddrA == btaddrB);

  EXPECT_TRUE(btaddr1 == btaddrB);

}



TEST_F(BtAddressTest, ToVector) {

  BtAddress btaddr1;

  BtAddress btaddr1_copy;

  BtAddress btaddr2;

  vector<uint8_t> octets1;

  vector<uint8_t> octets1_copy;

  vector<uint8_t> octets2;

  EXPECT_TRUE(btaddr1.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr1_copy.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr2.FromString(kTestAddr2));

  EXPECT_TRUE(btaddr1 == btaddr1_copy);

  EXPECT_TRUE(btaddr1 != btaddr2);

  btaddr1.ToVector(octets1);

  btaddr2.ToVector(octets2);

  btaddr1_copy.ToVector(octets1_copy);

  EXPECT_TRUE(octets1 != octets2);

  EXPECT_TRUE(octets1 == octets1_copy);

  EXPECT_TRUE(octets1.size() == BtAddress::kOctets);

  btaddr1.ToVector(octets1);

  EXPECT_TRUE(octets1.size() == (2 * BtAddress::kOctets));

}



TEST_F(BtAddressTest, ToString) {

  BtAddress btaddr_zeros;

  BtAddress btaddr1;

  EXPECT_TRUE(btaddr_zeros.FromString(kZeros));

  EXPECT_TRUE(btaddr1.FromString(kTestAddr1));

  EXPECT_TRUE(btaddr_zeros.ToString() == kZeros);

  EXPECT_TRUE(btaddr1.ToString() == kTestAddr1);

  EXPECT_TRUE(btaddr_zeros.ToString() != kTestAddr1);

  EXPECT_TRUE(btaddr1.ToString() != kZeros);

}



}  // namespace test_vendor_lib