/******************************************************************************
|
*
|
* Copyright 2014 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 <arpa/inet.h>
|
#include <gtest/gtest.h>
|
#include "osi/test/AllocationTestHarness.h"
|
|
#include "btcore/include/device_class.h"
|
|
::testing::AssertionResult check_bitfield(const char* m_expr,
|
const char* n_expr, int m, int n) {
|
if (m == n) return ::testing::AssertionSuccess();
|
|
std::stringstream ss;
|
|
ss.str("");
|
ss << std::showbase << std::hex << std::setw(8) << std::setfill('0') << m;
|
std::string expected_str = ss.str();
|
|
ss.str("");
|
ss << std::showbase << std::hex << std::setw(8) << std::setfill('0') << n;
|
std::string actual_str = ss.str();
|
|
return ::testing::AssertionFailure() << m_expr << " and " << n_expr << " ( "
|
<< expected_str << " vs " << actual_str
|
<< " )";
|
}
|
|
class DeviceClassTest : public AllocationTestHarness {};
|
|
TEST_F(DeviceClassTest, cod_sizeof) {
|
uint8_t dc_stream[] = {0x00, 0x00, 0x00, 0x00};
|
bt_device_class_t dc0;
|
device_class_from_stream(&dc0, dc_stream);
|
EXPECT_EQ((size_t)3, sizeof(dc0));
|
}
|
|
TEST_F(DeviceClassTest, simple) {
|
uint8_t dc_stream[][sizeof(bt_device_class_t)] = {
|
{0x00, 0x00, 0x00}, {0xff, 0xff, 0xff}, {0xaa, 0x55, 0xaa},
|
{0x01, 0x23, 0x45}, {0x20, 0x07, 0x14},
|
};
|
|
for (size_t i = 0; i < sizeof(dc_stream) / sizeof(bt_device_class_t); i++) {
|
bt_device_class_t dc;
|
device_class_from_stream(&dc, (uint8_t*)&dc_stream[i]);
|
|
uint8_t* to_stream = (uint8_t*)&dc;
|
EXPECT_PRED_FORMAT2(check_bitfield, (unsigned)dc_stream[i][0],
|
to_stream[0]);
|
EXPECT_PRED_FORMAT2(check_bitfield, (unsigned)dc_stream[i][1],
|
to_stream[1]);
|
EXPECT_PRED_FORMAT2(check_bitfield, (unsigned)dc_stream[i][2],
|
to_stream[2]);
|
}
|
}
|
|
TEST_F(DeviceClassTest, to_stream) {
|
{
|
bt_device_class_t dc;
|
|
uint8_t dc_stream0[] = {0x00, 0x00, 0x00, 0xaa};
|
device_class_from_stream(&dc, dc_stream0);
|
|
uint8_t dc_stream1[] = {0x00, 0x00, 0x00, 0x00};
|
int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));
|
EXPECT_EQ(3, rc);
|
|
uint32_t val = 0;
|
memcpy(&val, &dc, sizeof(dc));
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, val);
|
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[0]);
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[1]);
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00, dc_stream1[2]);
|
}
|
|
{
|
uint8_t dc_stream0[] = {0xaa, 0x55, 0xaa, 0x55};
|
uint8_t dc_stream1[] = {0x00, 0x00, 0x00, 0x00};
|
|
bt_device_class_t dc;
|
device_class_from_stream(&dc, dc_stream0);
|
|
int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));
|
EXPECT_EQ(3, rc);
|
uint32_t val = 0;
|
memcpy(&val, &dc, sizeof(dc));
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00aa55aa, val);
|
|
EXPECT_PRED_FORMAT2(check_bitfield, 0xaa, dc_stream1[0]);
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x55, dc_stream1[1]);
|
EXPECT_PRED_FORMAT2(check_bitfield, 0xaa, dc_stream1[2]);
|
}
|
|
{
|
uint8_t dc_stream0[] = {0x01, 0x23, 0x45, 0x67};
|
uint8_t dc_stream1[] = {0x00, 0x00, 0x00, 0x00};
|
|
bt_device_class_t dc;
|
device_class_from_stream(&dc, dc_stream0);
|
|
int rc = device_class_to_stream(&dc, dc_stream1, sizeof(dc_stream1));
|
EXPECT_EQ(3, rc);
|
uint32_t val = 0;
|
memcpy(&val, &dc, sizeof(dc));
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x452301, val);
|
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x01, dc_stream1[0]);
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x23, dc_stream1[1]);
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x45, dc_stream1[2]);
|
}
|
}
|
|
TEST_F(DeviceClassTest, limited_discoverable_mode) {
|
uint8_t dc_stream[] = {0x00, 0x00, 0x00};
|
bt_device_class_t dc;
|
device_class_from_stream(&dc, dc_stream);
|
uint32_t test = 0;
|
memcpy(&test, &dc, sizeof(dc));
|
|
EXPECT_FALSE(device_class_get_limited(&dc));
|
EXPECT_EQ((unsigned)0x00000000, test);
|
|
device_class_set_limited(&dc, true);
|
test = 0;
|
memcpy(&test, &dc, sizeof(dc));
|
EXPECT_TRUE(device_class_get_limited(&dc));
|
EXPECT_EQ((unsigned)0x00002000, test);
|
|
device_class_set_limited(&dc, false);
|
test = 0;
|
memcpy(&test, &dc, sizeof(dc));
|
EXPECT_FALSE(device_class_get_limited(&dc));
|
EXPECT_EQ((unsigned)0x00000000, test);
|
|
device_class_set_limited(&dc, true);
|
test = 0;
|
memcpy(&test, &dc, sizeof(dc));
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00002000, test);
|
|
device_class_set_limited(&dc, false);
|
test = 0;
|
memcpy(&test, &dc, sizeof(dc));
|
EXPECT_PRED_FORMAT2(check_bitfield, 0x00000000, test);
|
}
|
|
TEST_F(DeviceClassTest, equals) {
|
uint8_t dc_stream0[] = {0x00, 0x01, 0x02};
|
uint8_t dc_stream1[] = {0x00, 0x02, 0x03};
|
|
bt_device_class_t dc0;
|
device_class_from_stream(&dc0, dc_stream0);
|
bt_device_class_t dc1;
|
device_class_from_stream(&dc1, dc_stream1);
|
EXPECT_FALSE(device_class_equals(&dc0, &dc1));
|
}
|
|
TEST_F(DeviceClassTest, copy) {
|
uint8_t dc_stream0[] = {0xaa, 0x55, 0x33};
|
bt_device_class_t dc0;
|
device_class_from_stream(&dc0, dc_stream0);
|
bt_device_class_t dc1;
|
EXPECT_TRUE(device_class_copy(&dc1, &dc0));
|
EXPECT_TRUE(device_class_equals(&dc0, &dc1));
|
}
|
|
TEST_F(DeviceClassTest, from_int) {
|
bt_device_class_t dc1;
|
int cod1 = 0x5a020c; // 5898764
|
device_class_from_int(&dc1, cod1);
|
|
uint8_t dc_stream[] = {0x0c, 0x02, 0x5a};
|
bt_device_class_t dc2;
|
device_class_from_stream(&dc2, dc_stream);
|
EXPECT_TRUE(device_class_equals(&dc1, &dc2));
|
}
|
|
TEST_F(DeviceClassTest, to_int) {
|
bt_device_class_t dc1 = {{0x0c, 0x02, 0x5a}};
|
int cod1 = device_class_to_int(&dc1);
|
|
EXPECT_EQ(dc1._[0], 0x0c);
|
EXPECT_EQ(dc1._[1], 0x02);
|
EXPECT_EQ(dc1._[2], 0x5a);
|
|
bt_device_class_t dc2;
|
uint8_t dc_stream[] = {0x0c, 0x02, 0x5a};
|
device_class_from_stream(&dc2, dc_stream);
|
|
EXPECT_EQ(dc2._[0], 0x0c);
|
EXPECT_EQ(dc2._[1], 0x02);
|
EXPECT_EQ(dc2._[2], 0x5a);
|
|
int cod2 = device_class_to_int(&dc2);
|
EXPECT_EQ(cod1, cod2);
|
EXPECT_EQ(cod1, 0x5a020c); // 5898764
|
}
|
|
TEST_F(DeviceClassTest, endian) {
|
bt_device_class_t dc;
|
int cod1 = 0x200714; // 2098964
|
device_class_from_int(&dc, cod1);
|
|
EXPECT_EQ(dc._[0], 0x14);
|
EXPECT_EQ(dc._[1], 0x07);
|
EXPECT_EQ(dc._[2], 0x20);
|
|
int cod2 = device_class_to_int(&dc);
|
EXPECT_EQ(cod1, cod2);
|
EXPECT_EQ(cod2, 0x200714); // 2098964
|
}
|
