1 /*
2 * Copyright 2021 The Android Open Source Project
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 <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include <cstring>
21 #include <map>
22 #include <utility>
23
24 #include "osi/include/log.h"
25 #include "stack/include/hcidefs.h"
26 #include "stack/include/l2cdefs.h"
27 #include "test/common/mock_functions.h"
28 #include "test/mock/mock_hcic_hcicmds.h"
29
30 namespace mock = test::mock::hcic_hcicmds;
31
32 using testing::_;
33 using testing::DoAll;
34 using testing::NotNull;
35 using testing::Pointee;
36 using testing::Return;
37 using testing::SaveArg;
38 using testing::SaveArgPointee;
39 using testing::StrEq;
40 using testing::StrictMock;
41 using testing::Test;
42
43 class StackHciTest : public Test {
44 public:
45 protected:
SetUp()46 void SetUp() override { reset_mock_function_count_map(); }
TearDown()47 void TearDown() override {}
48 };
49
TEST_F(StackHciTest,hci_preamble)50 TEST_F(StackHciTest, hci_preamble) {
51 {
52 HciDataPreamble preamble;
53
54 ASSERT_EQ(sizeof(preamble), HCI_DATA_PREAMBLE_SIZE);
55
56 preamble.bits.handle = 0xfff;
57 preamble.bits.boundary = 0x3;
58 preamble.bits.broadcast = 0x1;
59 preamble.bits.unused15 = 0x0;
60 preamble.bits.length = 0xffff;
61
62 ASSERT_EQ(0x7fff, preamble.raw.word0);
63 ASSERT_EQ(0xffff, preamble.raw.word1);
64
65 const uint8_t exp[] = {0xff, 0x7f, 0xff, 0xff};
66 uint8_t act[sizeof(preamble)];
67 preamble.Serialize(act);
68 ASSERT_EQ(0, std::memcmp(exp, act, sizeof(preamble)));
69 }
70
71 {
72 HciDataPreamble preamble;
73 preamble.raw.word0 =
74 0x123 | (L2CAP_PKT_START_NON_FLUSHABLE << L2CAP_PKT_TYPE_SHIFT);
75 preamble.raw.word1 = 0x4567;
76
77 ASSERT_EQ(sizeof(preamble), HCI_DATA_PREAMBLE_SIZE);
78
79 ASSERT_EQ(0x0123, preamble.raw.word0);
80 ASSERT_EQ(0x4567, preamble.raw.word1);
81
82 const uint8_t exp[] = {0x23, 0x01, 0x67, 0x45};
83 uint8_t act[sizeof(preamble)];
84 preamble.Serialize(act);
85 ASSERT_EQ(0, std::memcmp(exp, act, sizeof(preamble)));
86 }
87 {
88 HciDataPreamble preamble;
89 preamble.raw.word0 = 0x123 | (L2CAP_PKT_START << L2CAP_PKT_TYPE_SHIFT);
90 preamble.raw.word1 = 0x4567;
91
92 ASSERT_EQ(sizeof(preamble), HCI_DATA_PREAMBLE_SIZE);
93
94 ASSERT_EQ(0x2123, preamble.raw.word0);
95 ASSERT_EQ(0x4567, preamble.raw.word1);
96
97 const uint8_t exp[] = {0x23, 0x21, 0x67, 0x45};
98 uint8_t act[sizeof(preamble)];
99 preamble.Serialize(act);
100 ASSERT_EQ(0, std::memcmp(exp, act, sizeof(preamble)));
101 }
102
103 {
104 HciDataPreamble preamble;
105 preamble.raw.word0 = 0x0 | (L2CAP_PKT_START << L2CAP_PKT_TYPE_SHIFT);
106 preamble.raw.word1 = 0x0;
107
108 ASSERT_EQ(sizeof(preamble), HCI_DATA_PREAMBLE_SIZE);
109
110 ASSERT_EQ(0x2000, preamble.raw.word0);
111 ASSERT_EQ(0x0000, preamble.raw.word1);
112
113 const uint8_t exp[] = {0x00, 0x20, 0x00, 0x00};
114 uint8_t act[sizeof(preamble)];
115 preamble.Serialize(act);
116 ASSERT_EQ(0, std::memcmp(exp, act, sizeof(preamble)));
117 }
118
119 {
120 HciDataPreamble preamble;
121 preamble.raw.word0 = 0x0 | (L2CAP_PKT_START << L2CAP_PKT_TYPE_SHIFT);
122 preamble.raw.word1 = 0x0;
123
124 ASSERT_TRUE(preamble.IsFlushable());
125
126 preamble.raw.word0 =
127 0x0 | (L2CAP_PKT_START << L2CAP_PKT_START_NON_FLUSHABLE);
128 ASSERT_TRUE(!preamble.IsFlushable());
129 }
130 }
131
TEST_F(StackHciTest,hci_error_code_text)132 TEST_F(StackHciTest, hci_error_code_text) {
133 std::vector<std::pair<tHCI_ERROR_CODE, std::string>> errors = {
134 std::make_pair(HCI_SUCCESS, "HCI_SUCCESS"),
135 std::make_pair(HCI_ERR_ILLEGAL_COMMAND, "HCI_ERR_ILLEGAL_COMMAND"),
136 std::make_pair(HCI_ERR_NO_CONNECTION, "HCI_ERR_NO_CONNECTION"),
137 std::make_pair(HCI_ERR_HW_FAILURE, "HCI_ERR_HW_FAILURE"),
138 std::make_pair(HCI_ERR_PAGE_TIMEOUT, "HCI_ERR_PAGE_TIMEOUT"),
139 std::make_pair(HCI_ERR_AUTH_FAILURE, "HCI_ERR_AUTH_FAILURE"),
140 std::make_pair(HCI_ERR_KEY_MISSING, "HCI_ERR_KEY_MISSING"),
141 std::make_pair(HCI_ERR_MEMORY_FULL, "HCI_ERR_MEMORY_FULL"),
142 std::make_pair(HCI_ERR_CONNECTION_TOUT, "HCI_ERR_CONNECTION_TOUT"),
143 std::make_pair(HCI_ERR_MAX_NUM_OF_CONNECTIONS,
144 "HCI_ERR_MAX_NUM_OF_CONNECTIONS"),
145 std::make_pair(HCI_ERR_MAX_NUM_OF_SCOS, "HCI_ERR_MAX_NUM_OF_SCOS"),
146 std::make_pair(HCI_ERR_CONNECTION_EXISTS, "HCI_ERR_CONNECTION_EXISTS"),
147 std::make_pair(HCI_ERR_COMMAND_DISALLOWED, "HCI_ERR_COMMAND_DISALLOWED"),
148 std::make_pair(HCI_ERR_HOST_REJECT_RESOURCES,
149 "HCI_ERR_HOST_REJECT_RESOURCES"),
150 std::make_pair(HCI_ERR_HOST_REJECT_SECURITY,
151 "HCI_ERR_HOST_REJECT_SECURITY"),
152 std::make_pair(HCI_ERR_HOST_REJECT_DEVICE, "HCI_ERR_HOST_REJECT_DEVICE"),
153 std::make_pair(HCI_ERR_HOST_TIMEOUT, "HCI_ERR_HOST_TIMEOUT"),
154 std::make_pair(HCI_ERR_ILLEGAL_PARAMETER_FMT,
155 "HCI_ERR_ILLEGAL_PARAMETER_FMT"),
156 std::make_pair(HCI_ERR_PEER_USER, "HCI_ERR_PEER_USER"),
157 std::make_pair(HCI_ERR_REMOTE_LOW_RESOURCE,
158 "HCI_ERR_REMOTE_LOW_RESOURCE"),
159 std::make_pair(HCI_ERR_REMOTE_POWER_OFF, "HCI_ERR_REMOTE_POWER_OFF"),
160 std::make_pair(HCI_ERR_CONN_CAUSE_LOCAL_HOST,
161 "HCI_ERR_CONN_CAUSE_LOCAL_HOST"),
162 std::make_pair(HCI_ERR_REPEATED_ATTEMPTS, "HCI_ERR_REPEATED_ATTEMPTS"),
163 std::make_pair(HCI_ERR_PAIRING_NOT_ALLOWED,
164 "HCI_ERR_PAIRING_NOT_ALLOWED"),
165 std::make_pair(HCI_ERR_UNSUPPORTED_REM_FEATURE,
166 "HCI_ERR_UNSUPPORTED_REM_FEATURE"),
167 std::make_pair(HCI_ERR_UNSPECIFIED, "HCI_ERR_UNSPECIFIED"),
168 std::make_pair(HCI_ERR_LMP_RESPONSE_TIMEOUT,
169 "HCI_ERR_LMP_RESPONSE_TIMEOUT"),
170 std::make_pair(HCI_ERR_LMP_ERR_TRANS_COLLISION,
171 "HCI_ERR_LMP_ERR_TRANS_COLLISION"),
172 std::make_pair(HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE,
173 "HCI_ERR_ENCRY_MODE_NOT_ACCEPTABLE"),
174 std::make_pair(HCI_ERR_UNIT_KEY_USED, "HCI_ERR_UNIT_KEY_USED"),
175 std::make_pair(HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED,
176 "HCI_ERR_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED"),
177 std::make_pair(HCI_ERR_DIFF_TRANSACTION_COLLISION,
178 "HCI_ERR_DIFF_TRANSACTION_COLLISION"),
179 std::make_pair(HCI_ERR_INSUFFCIENT_SECURITY,
180 "HCI_ERR_INSUFFCIENT_SECURITY"),
181 std::make_pair(HCI_ERR_ROLE_SWITCH_PENDING,
182 "HCI_ERR_ROLE_SWITCH_PENDING"),
183 std::make_pair(HCI_ERR_ROLE_SWITCH_FAILED, "HCI_ERR_ROLE_SWITCH_FAILED"),
184 std::make_pair(HCI_ERR_HOST_BUSY_PAIRING, "HCI_ERR_HOST_BUSY_PAIRING"),
185 std::make_pair(HCI_ERR_UNACCEPT_CONN_INTERVAL,
186 "HCI_ERR_UNACCEPT_CONN_INTERVAL"),
187 std::make_pair(HCI_ERR_ADVERTISING_TIMEOUT,
188 "HCI_ERR_ADVERTISING_TIMEOUT"),
189 std::make_pair(HCI_ERR_CONN_FAILED_ESTABLISHMENT,
190 "HCI_ERR_CONN_FAILED_ESTABLISHMENT"),
191 std::make_pair(HCI_ERR_LIMIT_REACHED, "HCI_ERR_LIMIT_REACHED"),
192 };
193 for (const auto& error : errors) {
194 ASSERT_STREQ(error.second.c_str(),
195 hci_error_code_text(error.first).c_str());
196 }
197 for (const auto& error : errors) {
198 ASSERT_STREQ(error.second.c_str(),
199 hci_error_code_text(error.first).c_str());
200 }
201 auto unknown = base::StringPrintf("UNKNOWN[0x%02hx]",
202 std::numeric_limits<std::uint8_t>::max());
203 ASSERT_STREQ(
204 unknown.c_str(),
205 hci_error_code_text(static_cast<tHCI_ERROR_CODE>(
206 std::numeric_limits<std::uint8_t>::max()))
207 .c_str());
208 }
209