1//
2//  Copyright (C) 2015 Google, Inc.
3//
4//  Licensed under the Apache License, Version 2.0 (the "License");
5//  you may not use this file except in compliance with the License.
6//  You may obtain a copy of the License at:
7//
8//  http://www.apache.org/licenses/LICENSE-2.0
9//
10//  Unless required by applicable law or agreed to in writing, software
11//  distributed under the License is distributed on an "AS IS" BASIS,
12//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13//  See the License for the specific language governing permissions and
14//  limitations under the License.
15//
16
17#include <gtest/gtest.h>
18
19#include "service/common/bluetooth/advertise_data.h"
20#include "service/common/bluetooth/advertise_settings.h"
21#include "service/common/bluetooth/binder/parcel_helpers.h"
22
23using android::Parcel;
24
25using bluetooth::AdvertiseData;
26using bluetooth::AdvertiseSettings;
27using bluetooth::GattIdentifier;
28using bluetooth::ScanFilter;
29using bluetooth::ScanResult;
30using bluetooth::ScanSettings;
31using bluetooth::UUID;
32
33namespace ipc {
34namespace binder {
35namespace {
36
37bool TestAdvertiseData(const AdvertiseData &adv_in) {
38  Parcel parcel;
39
40  WriteAdvertiseDataToParcel(adv_in, &parcel);
41  parcel.setDataPosition(0);
42  auto adv_out = CreateAdvertiseDataFromParcel(parcel);
43
44  return adv_in == *adv_out;
45}
46
47bool TestAdvertiseSettings(const AdvertiseSettings &settings_in) {
48  Parcel parcel;
49
50  WriteAdvertiseSettingsToParcel(settings_in, &parcel);
51  parcel.setDataPosition(0);
52  auto settings_out = CreateAdvertiseSettingsFromParcel(parcel);
53
54  return settings_in == *settings_out;
55}
56
57bool TestUUID(const UUID& uuid_in) {
58  Parcel parcel;
59
60  WriteUUIDToParcel(uuid_in, &parcel);
61  parcel.setDataPosition(0);
62  auto uuid_out = CreateUUIDFromParcel(parcel);
63
64  return uuid_in == *uuid_out;
65}
66
67bool TestGattIdentifier(const GattIdentifier& id_in) {
68  Parcel parcel;
69
70  WriteGattIdentifierToParcel(id_in, &parcel);
71  parcel.setDataPosition(0);
72  auto id_out = CreateGattIdentifierFromParcel(parcel);
73
74  return id_in == *id_out;
75}
76
77bool TestScanSettings(const ScanSettings& settings_in) {
78  Parcel parcel;
79  WriteScanSettingsToParcel(settings_in, &parcel);
80  parcel.setDataPosition(0);
81  auto settings_out = CreateScanSettingsFromParcel(parcel);
82
83  return settings_in == *settings_out;
84}
85
86bool TestScanFilter(const ScanFilter& filter_in) {
87  Parcel parcel;
88  WriteScanFilterToParcel(filter_in, &parcel);
89  parcel.setDataPosition(0);
90  auto filter_out = CreateScanFilterFromParcel(parcel);
91
92  return filter_in == *filter_out;
93}
94
95bool TestScanResult(const ScanResult& result_in) {
96  Parcel parcel;
97  WriteScanResultToParcel(result_in, &parcel);
98  parcel.setDataPosition(0);
99  auto result_out = CreateScanResultFromParcel(parcel);
100  assert(result_out.get() != nullptr);
101
102  return result_in == *result_out;
103}
104
105TEST(ParcelHelpersTest, EmptyAdvertiseData) {
106  std::vector<uint8_t> data;
107  AdvertiseData adv(data);
108
109  EXPECT_TRUE(TestAdvertiseData(adv));
110}
111
112TEST(ParcelHelpersTest, NonEmptyAdvertiseData) {
113  std::vector<uint8_t> data{ 0x02, 0x02, 0x00 };
114  AdvertiseData adv0(data);
115  adv0.set_include_tx_power_level(true);
116  EXPECT_TRUE(TestAdvertiseData(adv0));
117
118  AdvertiseData adv1(data);
119  adv1.set_include_device_name(true);
120  EXPECT_TRUE(TestAdvertiseData(adv1));
121
122  AdvertiseData adv2(data);
123  adv2.set_include_tx_power_level(true);
124  adv2.set_include_device_name(true);
125  EXPECT_TRUE(TestAdvertiseData(adv2));
126}
127
128TEST(ParcelHelpersTest, DefaultAdvertiseSettings) {
129  AdvertiseSettings settings;
130  EXPECT_TRUE(TestAdvertiseSettings(settings));
131}
132
133TEST(ParcelHelpersTest, NonEmptyAdvertiseSettings) {
134  AdvertiseSettings settings(
135      AdvertiseSettings::MODE_BALANCED,
136      base::TimeDelta::FromMilliseconds(150),
137      AdvertiseSettings::TX_POWER_LEVEL_HIGH,
138      false /* connectable */);
139  EXPECT_TRUE(TestAdvertiseSettings(settings));
140}
141
142TEST(ParcelHelpersTest, UUID) {
143  // Try a whole bunch of UUIDs.
144  for (int i = 0; i < 10; i++) {
145    UUID uuid = UUID::GetRandom();
146    TestUUID(uuid);
147  }
148}
149
150TEST(ParcelHelpersTest, GattIdentifier) {
151  UUID uuid0 = UUID::GetRandom();
152  UUID uuid1 = UUID::GetRandom();
153  UUID uuid2 = UUID::GetRandom();
154
155  auto service_id = GattIdentifier::CreateServiceId(
156      "01:23:45:67:89:ab", 5, uuid0, false);
157  auto char_id = GattIdentifier::CreateCharacteristicId(3, uuid1, *service_id);
158  auto desc_id = GattIdentifier::CreateDescriptorId(10, uuid2, *char_id);
159
160  TestGattIdentifier(*service_id);
161  TestGattIdentifier(*char_id);
162  TestGattIdentifier(*desc_id);
163}
164
165TEST(ParcelHelpersTest, ScanSettings) {
166  ScanSettings settings0;
167  ScanSettings settings1(
168      ScanSettings::MODE_BALANCED,
169      ScanSettings::CALLBACK_TYPE_FIRST_MATCH,
170      ScanSettings::RESULT_TYPE_ABBREVIATED,
171      base::TimeDelta::FromMilliseconds(150),
172      ScanSettings::MATCH_MODE_STICKY,
173      ScanSettings::MATCH_COUNT_FEW_ADVERTISEMENTS);
174
175  EXPECT_TRUE(TestScanSettings(settings0));
176  EXPECT_TRUE(TestScanSettings(settings1));
177}
178
179TEST(ParcelHelpersTest, ScanFilter) {
180  ScanFilter filter;
181
182  filter.set_device_name("Test Device Name");
183  ASSERT_TRUE(filter.SetDeviceAddress("01:02:04:AB:CD:EF"));
184  EXPECT_TRUE(TestScanFilter(filter));
185
186  UUID uuid = UUID::GetRandom();
187  filter.SetServiceUuid(uuid);
188  EXPECT_TRUE(TestScanFilter(filter));
189
190  UUID mask = UUID::GetRandom();
191  filter.SetServiceUuidWithMask(uuid, mask);
192  EXPECT_TRUE(TestScanFilter(filter));
193}
194
195TEST(ParcelHelpersTest, ScanResult) {
196  const char kTestAddress[] = "01:02:03:AB:CD:EF";
197
198  const std::vector<uint8_t> kEmptyBytes;
199  const std::vector<uint8_t> kTestBytes{ 0x01, 0x02, 0x03 };
200
201  const int kTestRssi = 127;
202
203  ScanResult result0(kTestAddress, kEmptyBytes, kTestRssi);
204  ScanResult result1(kTestAddress, kTestBytes, kTestRssi);
205
206  EXPECT_TRUE(TestScanResult(result0));
207  EXPECT_TRUE(TestScanResult(result1));
208}
209
210}  // namespace
211}  // namespace binder
212}  // namespace ipc
213