1 /*
2 * Copyright (C) 2022 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 <android-base/logging.h>
18 #include <android-base/macros.h>
19 #include <gmock/gmock.h>
20
21 #include "aidl_struct_util.h"
22
23 using testing::Test;
24
25 namespace {
26 constexpr uint32_t kMacId1 = 1;
27 constexpr uint32_t kMacId2 = 2;
28 constexpr uint32_t kIfaceChannel1 = 3;
29 constexpr uint32_t kIfaceChannel2 = 5;
30 constexpr char kIfaceName1[] = "wlan0";
31 constexpr char kIfaceName2[] = "wlan1";
32 constexpr uint8_t kMacAddress[] = {0x02, 0x12, 0x45, 0x56, 0xab, 0xcc};
33 byte LCI[] = {0x27, 0x1A, 0x1, 0x00, 0x8, 0x01, 0x00, 0x08, 0x00, 0x10, 0x52,
34 0x83, 0x4d, 0x12, 0xef, 0xd2, 0xb0, 0x8b, 0x9b, 0x4b, 0xf1, 0xcc,
35 0x2c, 0x00, 0x00, 0x41, 0x06, 0x03, 0x06, 0x00, 0x80};
36 byte LCR[] = {0x27, 0xE, 0x1, 0x00, 0xB, 0x01, 0x00, 0x0b, 0x00, 0x09,
37 0x55, 0x53, 0x18, 0x05, 0x39, 0x34, 0x30, 0x34, 0x33};
38
39 constexpr int kNumScanResult = 2;
40 constexpr int kRssi[] = {-60, -70};
41 constexpr uint8_t kBssid[] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0};
42 constexpr uint8_t kSsidLen = 6;
43 constexpr char kSsid[] = {'a', 'b', 'c', 'd', 'e', '\0'};
44 } // namespace
45
46 namespace aidl {
47 namespace android {
48 namespace hardware {
49 namespace wifi {
50
51 class AidlStructUtilTest : public Test {};
52
TEST_F(AidlStructUtilTest,CanConvertLegacyWifiMacInfosToAidlWithOneMac)53 TEST_F(AidlStructUtilTest, CanConvertLegacyWifiMacInfosToAidlWithOneMac) {
54 std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
55 legacy_hal::WifiMacInfo legacy_mac_info1 = {
56 .wlan_mac_id = kMacId1,
57 .mac_band = legacy_hal::WLAN_MAC_5_0_BAND | legacy_hal::WLAN_MAC_2_4_BAND};
58 legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1, .channel = kIfaceChannel1};
59 legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2, .channel = kIfaceChannel2};
60 legacy_mac_info1.iface_infos.push_back(legacy_iface_info1);
61 legacy_mac_info1.iface_infos.push_back(legacy_iface_info2);
62 legacy_mac_infos.push_back(legacy_mac_info1);
63
64 std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
65 ASSERT_TRUE(aidl_struct_util::convertLegacyWifiMacInfosToAidl(legacy_mac_infos,
66 &aidl_radio_mode_infos));
67
68 ASSERT_EQ(1u, aidl_radio_mode_infos.size());
69 auto aidl_radio_mode_info1 = aidl_radio_mode_infos[0];
70 EXPECT_EQ(legacy_mac_info1.wlan_mac_id, (uint32_t)aidl_radio_mode_info1.radioId);
71 EXPECT_EQ(WifiBand::BAND_24GHZ_5GHZ, aidl_radio_mode_info1.bandInfo);
72 ASSERT_EQ(2u, aidl_radio_mode_info1.ifaceInfos.size());
73 auto aidl_iface_info1 = aidl_radio_mode_info1.ifaceInfos[0];
74 EXPECT_EQ(legacy_iface_info1.name, aidl_iface_info1.name);
75 EXPECT_EQ(static_cast<int32_t>(legacy_iface_info1.channel), aidl_iface_info1.channel);
76 auto aidl_iface_info2 = aidl_radio_mode_info1.ifaceInfos[1];
77 EXPECT_EQ(legacy_iface_info2.name, aidl_iface_info2.name);
78 EXPECT_EQ(static_cast<int32_t>(legacy_iface_info2.channel), aidl_iface_info2.channel);
79 }
80
TEST_F(AidlStructUtilTest,CanConvertLegacyWifiMacInfosToAidlWithTwoMac)81 TEST_F(AidlStructUtilTest, CanConvertLegacyWifiMacInfosToAidlWithTwoMac) {
82 std::vector<legacy_hal::WifiMacInfo> legacy_mac_infos;
83 legacy_hal::WifiMacInfo legacy_mac_info1 = {.wlan_mac_id = kMacId1,
84 .mac_band = legacy_hal::WLAN_MAC_5_0_BAND};
85 legacy_hal::WifiIfaceInfo legacy_iface_info1 = {.name = kIfaceName1, .channel = kIfaceChannel1};
86 legacy_hal::WifiMacInfo legacy_mac_info2 = {.wlan_mac_id = kMacId2,
87 .mac_band = legacy_hal::WLAN_MAC_2_4_BAND};
88 legacy_hal::WifiIfaceInfo legacy_iface_info2 = {.name = kIfaceName2, .channel = kIfaceChannel2};
89 legacy_mac_info1.iface_infos.push_back(legacy_iface_info1);
90 legacy_mac_infos.push_back(legacy_mac_info1);
91 legacy_mac_info2.iface_infos.push_back(legacy_iface_info2);
92 legacy_mac_infos.push_back(legacy_mac_info2);
93
94 std::vector<IWifiChipEventCallback::RadioModeInfo> aidl_radio_mode_infos;
95 ASSERT_TRUE(aidl_struct_util::convertLegacyWifiMacInfosToAidl(legacy_mac_infos,
96 &aidl_radio_mode_infos));
97
98 ASSERT_EQ(2u, aidl_radio_mode_infos.size());
99
100 // Find mac info 1.
101 const auto aidl_radio_mode_info1 =
102 std::find_if(aidl_radio_mode_infos.begin(), aidl_radio_mode_infos.end(),
103 [&legacy_mac_info1](const IWifiChipEventCallback::RadioModeInfo& x) {
104 return (uint32_t)x.radioId == legacy_mac_info1.wlan_mac_id;
105 });
106 ASSERT_NE(aidl_radio_mode_infos.end(), aidl_radio_mode_info1);
107 EXPECT_EQ(WifiBand::BAND_5GHZ, aidl_radio_mode_info1->bandInfo);
108 ASSERT_EQ(1u, aidl_radio_mode_info1->ifaceInfos.size());
109 auto aidl_iface_info1 = aidl_radio_mode_info1->ifaceInfos[0];
110 EXPECT_EQ(legacy_iface_info1.name, aidl_iface_info1.name);
111 EXPECT_EQ(static_cast<int32_t>(legacy_iface_info1.channel), aidl_iface_info1.channel);
112
113 // Find mac info 2.
114 const auto aidl_radio_mode_info2 =
115 std::find_if(aidl_radio_mode_infos.begin(), aidl_radio_mode_infos.end(),
116 [&legacy_mac_info2](const IWifiChipEventCallback::RadioModeInfo& x) {
117 return (uint32_t)x.radioId == legacy_mac_info2.wlan_mac_id;
118 });
119 ASSERT_NE(aidl_radio_mode_infos.end(), aidl_radio_mode_info2);
120 EXPECT_EQ(WifiBand::BAND_24GHZ, aidl_radio_mode_info2->bandInfo);
121 ASSERT_EQ(1u, aidl_radio_mode_info2->ifaceInfos.size());
122 auto aidl_iface_info2 = aidl_radio_mode_info2->ifaceInfos[0];
123 EXPECT_EQ(legacy_iface_info2.name, aidl_iface_info2.name);
124 EXPECT_EQ(static_cast<int32_t>(legacy_iface_info2.channel), aidl_iface_info2.channel);
125 }
126
TEST_F(AidlStructUtilTest,canConvertLegacyLinkLayerMlStatsToAidl)127 TEST_F(AidlStructUtilTest, canConvertLegacyLinkLayerMlStatsToAidl) {
128 legacy_hal::LinkLayerMlStats legacy_ml_stats{};
129 // Add two radio stats
130 legacy_ml_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
131 legacy_ml_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
132 wifi_link_state states[sizeof(wifi_link_state)] = {wifi_link_state::WIFI_LINK_STATE_UNKNOWN,
133 wifi_link_state::WIFI_LINK_STATE_NOT_IN_USE,
134 wifi_link_state::WIFI_LINK_STATE_IN_USE};
135 // Add two links.
136 legacy_ml_stats.links.push_back(legacy_hal::LinkStats{});
137 legacy_ml_stats.links.push_back(legacy_hal::LinkStats{});
138 // Set stats for each link.
139 for (legacy_hal::LinkStats& link : legacy_ml_stats.links) {
140 link.peers.push_back(legacy_hal::WifiPeerInfo{});
141 link.peers.push_back(legacy_hal::WifiPeerInfo{});
142 link.stat.beacon_rx = rand();
143 // MLO link id: 0 - 15
144 link.stat.link_id = rand() % 16;
145 link.stat.state = states[rand() % sizeof(states)];
146 // Maximum number of radios is limited to 3 for testing.
147 link.stat.radio = rand() % 4;
148 link.stat.frequency = rand();
149 // RSSI: 0 to -127
150 link.stat.rssi_mgmt = (rand() % 128) * -1;
151 link.stat.ac[legacy_hal::WIFI_AC_BE].rx_mpdu = rand();
152 link.stat.ac[legacy_hal::WIFI_AC_BE].tx_mpdu = rand();
153 link.stat.ac[legacy_hal::WIFI_AC_BE].mpdu_lost = rand();
154 link.stat.ac[legacy_hal::WIFI_AC_BE].retries = rand();
155 link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_min = rand();
156 link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_max = rand();
157 link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_avg = rand();
158 link.stat.ac[legacy_hal::WIFI_AC_BE].contention_num_samples = rand();
159
160 link.stat.ac[legacy_hal::WIFI_AC_BK].rx_mpdu = rand();
161 link.stat.ac[legacy_hal::WIFI_AC_BK].tx_mpdu = rand();
162 link.stat.ac[legacy_hal::WIFI_AC_BK].mpdu_lost = rand();
163 link.stat.ac[legacy_hal::WIFI_AC_BK].retries = rand();
164 link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_min = rand();
165 link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_max = rand();
166 link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_avg = rand();
167 link.stat.ac[legacy_hal::WIFI_AC_BK].contention_num_samples = rand();
168
169 link.stat.ac[legacy_hal::WIFI_AC_VI].rx_mpdu = rand();
170 link.stat.ac[legacy_hal::WIFI_AC_VI].tx_mpdu = rand();
171 link.stat.ac[legacy_hal::WIFI_AC_VI].mpdu_lost = rand();
172 link.stat.ac[legacy_hal::WIFI_AC_VI].retries = rand();
173 link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_min = rand();
174 link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_max = rand();
175 link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_avg = rand();
176 link.stat.ac[legacy_hal::WIFI_AC_VI].contention_num_samples = rand();
177
178 link.stat.ac[legacy_hal::WIFI_AC_VO].rx_mpdu = rand();
179 link.stat.ac[legacy_hal::WIFI_AC_VO].tx_mpdu = rand();
180 link.stat.ac[legacy_hal::WIFI_AC_VO].mpdu_lost = rand();
181 link.stat.ac[legacy_hal::WIFI_AC_VO].retries = rand();
182 link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_min = rand();
183 link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_max = rand();
184 link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_avg = rand();
185 link.stat.ac[legacy_hal::WIFI_AC_VO].contention_num_samples = rand();
186
187 link.stat.time_slicing_duty_cycle_percent = rand() % 101;
188 link.stat.num_peers = 2;
189
190 // Set peer stats for each of the peers.
191 for (auto& peer : link.peers) {
192 // Max station count is limited to 32 for testing.
193 peer.peer_info.bssload.sta_count = rand() % 33;
194 peer.peer_info.bssload.chan_util = rand() % 101;
195 wifi_rate_stat rate_stat1 = {
196 .rate = {3, 1, 2, 5, 0, 0},
197 .tx_mpdu = 0,
198 .rx_mpdu = 1,
199 .mpdu_lost = 2,
200 .retries = 3,
201 .retries_short = 4,
202 .retries_long = 5,
203 };
204 wifi_rate_stat rate_stat2 = {
205 .rate = {2, 2, 1, 6, 0, 1},
206 .tx_mpdu = 6,
207 .rx_mpdu = 7,
208 .mpdu_lost = 8,
209 .retries = 9,
210 .retries_short = 10,
211 .retries_long = 11,
212 };
213 peer.rate_stats.push_back(rate_stat1);
214 peer.rate_stats.push_back(rate_stat2);
215 }
216 }
217 // Set radio stats
218 for (auto& radio : legacy_ml_stats.radios) {
219 // Maximum number of radios is limited to 3 for testing.
220 radio.stats.radio = rand() % 4;
221 radio.stats.on_time = rand();
222 radio.stats.tx_time = rand();
223 radio.stats.rx_time = rand();
224 radio.stats.on_time_scan = rand();
225 radio.stats.on_time_nbd = rand();
226 radio.stats.on_time_gscan = rand();
227 radio.stats.on_time_roam_scan = rand();
228 radio.stats.on_time_pno_scan = rand();
229 radio.stats.on_time_hs20 = rand();
230 for (int i = 0; i < 4; i++) {
231 radio.tx_time_per_levels.push_back(rand());
232 }
233
234 legacy_hal::wifi_channel_stat channel_stat1 = {
235 .channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 2437, 2437, 0},
236 .on_time = 0x1111,
237 .cca_busy_time = 0x55,
238 };
239 legacy_hal::wifi_channel_stat channel_stat2 = {
240 .channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 5180, 5180, 0},
241 .on_time = 0x2222,
242 .cca_busy_time = 0x66,
243 };
244 radio.channel_stats.push_back(channel_stat1);
245 radio.channel_stats.push_back(channel_stat2);
246 }
247 // Convert to AIDL
248 StaLinkLayerStats converted{};
249 aidl_struct_util::convertLegacyLinkLayerMlStatsToAidl(legacy_ml_stats, &converted);
250 // Validate
251 int l = 0;
252 for (legacy_hal::LinkStats& link : legacy_ml_stats.links) {
253 EXPECT_EQ(link.stat.link_id, (uint8_t)converted.iface.links[l].linkId);
254 StaLinkLayerLinkStats::StaLinkState expectedState;
255 switch (link.stat.state) {
256 case wifi_link_state::WIFI_LINK_STATE_NOT_IN_USE:
257 expectedState = StaLinkLayerLinkStats::StaLinkState::NOT_IN_USE;
258 break;
259 case wifi_link_state::WIFI_LINK_STATE_IN_USE:
260 expectedState = StaLinkLayerLinkStats::StaLinkState::IN_USE;
261 break;
262 default:
263 expectedState = StaLinkLayerLinkStats::StaLinkState::UNKNOWN;
264 }
265 EXPECT_EQ(expectedState, converted.iface.links[l].state);
266 EXPECT_EQ(link.stat.radio, converted.iface.links[l].radioId);
267 EXPECT_EQ(link.stat.frequency, (uint32_t)converted.iface.links[l].frequencyMhz);
268 EXPECT_EQ(link.stat.beacon_rx, (uint32_t)converted.iface.links[l].beaconRx);
269 EXPECT_EQ(link.stat.rssi_mgmt, converted.iface.links[l].avgRssiMgmt);
270 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].rx_mpdu,
271 converted.iface.links[l].wmeBePktStats.rxMpdu);
272 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].tx_mpdu,
273 converted.iface.links[l].wmeBePktStats.txMpdu);
274 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].mpdu_lost,
275 converted.iface.links[l].wmeBePktStats.lostMpdu);
276 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].retries,
277 converted.iface.links[l].wmeBePktStats.retries);
278 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_min,
279 (uint32_t)converted.iface.links[l]
280 .wmeBeContentionTimeStats.contentionTimeMinInUsec);
281 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_max,
282 (uint32_t)converted.iface.links[l]
283 .wmeBeContentionTimeStats.contentionTimeMaxInUsec);
284 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].contention_time_avg,
285 (uint32_t)converted.iface.links[l]
286 .wmeBeContentionTimeStats.contentionTimeAvgInUsec);
287 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
288 (uint32_t)converted.iface.links[l].wmeBeContentionTimeStats.contentionNumSamples);
289
290 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].rx_mpdu,
291 converted.iface.links[l].wmeBkPktStats.rxMpdu);
292 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].tx_mpdu,
293 converted.iface.links[l].wmeBkPktStats.txMpdu);
294 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].mpdu_lost,
295 converted.iface.links[l].wmeBkPktStats.lostMpdu);
296 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].retries,
297 converted.iface.links[l].wmeBkPktStats.retries);
298 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_min,
299 (uint32_t)converted.iface.links[l]
300 .wmeBkContentionTimeStats.contentionTimeMinInUsec);
301 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_max,
302 (uint32_t)converted.iface.links[l]
303 .wmeBkContentionTimeStats.contentionTimeMaxInUsec);
304 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].contention_time_avg,
305 (uint32_t)converted.iface.links[l]
306 .wmeBkContentionTimeStats.contentionTimeAvgInUsec);
307 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
308 (uint32_t)converted.iface.links[l].wmeBkContentionTimeStats.contentionNumSamples);
309
310 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].rx_mpdu,
311 converted.iface.links[l].wmeViPktStats.rxMpdu);
312 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].tx_mpdu,
313 converted.iface.links[l].wmeViPktStats.txMpdu);
314 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].mpdu_lost,
315 converted.iface.links[l].wmeViPktStats.lostMpdu);
316 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].retries,
317 converted.iface.links[l].wmeViPktStats.retries);
318 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_min,
319 (uint32_t)converted.iface.links[l]
320 .wmeViContentionTimeStats.contentionTimeMinInUsec);
321 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_max,
322 (uint32_t)converted.iface.links[l]
323 .wmeViContentionTimeStats.contentionTimeMaxInUsec);
324 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].contention_time_avg,
325 (uint32_t)converted.iface.links[l]
326 .wmeViContentionTimeStats.contentionTimeAvgInUsec);
327 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
328 (uint32_t)converted.iface.links[l].wmeViContentionTimeStats.contentionNumSamples);
329
330 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].rx_mpdu,
331 converted.iface.links[l].wmeVoPktStats.rxMpdu);
332 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].tx_mpdu,
333 converted.iface.links[l].wmeVoPktStats.txMpdu);
334 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].mpdu_lost,
335 converted.iface.links[l].wmeVoPktStats.lostMpdu);
336 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].retries,
337 converted.iface.links[l].wmeVoPktStats.retries);
338 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_min,
339 (uint32_t)converted.iface.links[l]
340 .wmeVoContentionTimeStats.contentionTimeMinInUsec);
341 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_max,
342 (uint32_t)converted.iface.links[l]
343 .wmeVoContentionTimeStats.contentionTimeMaxInUsec);
344 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].contention_time_avg,
345 (uint32_t)converted.iface.links[l]
346 .wmeVoContentionTimeStats.contentionTimeAvgInUsec);
347 EXPECT_EQ(link.stat.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
348 (uint32_t)converted.iface.links[l].wmeVoContentionTimeStats.contentionNumSamples);
349
350 EXPECT_EQ(link.stat.time_slicing_duty_cycle_percent,
351 converted.iface.links[l].timeSliceDutyCycleInPercent);
352
353 EXPECT_EQ(link.peers.size(), converted.iface.links[l].peers.size());
354 for (size_t i = 0; i < link.peers.size(); i++) {
355 EXPECT_EQ(link.peers[i].peer_info.bssload.sta_count,
356 converted.iface.links[l].peers[i].staCount);
357 EXPECT_EQ(link.peers[i].peer_info.bssload.chan_util,
358 converted.iface.links[l].peers[i].chanUtil);
359 for (size_t j = 0; j < link.peers[i].rate_stats.size(); j++) {
360 EXPECT_EQ(
361 link.peers[i].rate_stats[j].rate.preamble,
362 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].rateInfo.preamble);
363 EXPECT_EQ(link.peers[i].rate_stats[j].rate.nss,
364 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].rateInfo.nss);
365 EXPECT_EQ(link.peers[i].rate_stats[j].rate.bw,
366 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].rateInfo.bw);
367 EXPECT_EQ(link.peers[i].rate_stats[j].rate.rateMcsIdx,
368 (uint32_t)converted.iface.links[l]
369 .peers[i]
370 .rateStats[j]
371 .rateInfo.rateMcsIdx);
372 EXPECT_EQ(link.peers[i].rate_stats[j].tx_mpdu,
373 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].txMpdu);
374 EXPECT_EQ(link.peers[i].rate_stats[j].rx_mpdu,
375 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].rxMpdu);
376 EXPECT_EQ(link.peers[i].rate_stats[j].mpdu_lost,
377 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].mpduLost);
378 EXPECT_EQ(link.peers[i].rate_stats[j].retries,
379 (uint32_t)converted.iface.links[l].peers[i].rateStats[j].retries);
380 }
381 }
382 ++l;
383 } // loop over links
384
385 EXPECT_EQ(legacy_ml_stats.radios.size(), converted.radios.size());
386 for (size_t i = 0; i < legacy_ml_stats.radios.size(); i++) {
387 EXPECT_EQ(legacy_ml_stats.radios[i].stats.radio, converted.radios[i].radioId);
388 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time,
389 (uint32_t)converted.radios[i].onTimeInMs);
390 EXPECT_EQ(legacy_ml_stats.radios[i].stats.tx_time,
391 (uint32_t)converted.radios[i].txTimeInMs);
392 EXPECT_EQ(legacy_ml_stats.radios[i].stats.rx_time,
393 (uint32_t)converted.radios[i].rxTimeInMs);
394 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time_scan,
395 (uint32_t)converted.radios[i].onTimeInMsForScan);
396 EXPECT_EQ(legacy_ml_stats.radios[i].tx_time_per_levels.size(),
397 converted.radios[i].txTimeInMsPerLevel.size());
398 for (size_t j = 0; j < legacy_ml_stats.radios[i].tx_time_per_levels.size(); j++) {
399 EXPECT_EQ(legacy_ml_stats.radios[i].tx_time_per_levels[j],
400 (uint32_t)converted.radios[i].txTimeInMsPerLevel[j]);
401 }
402 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time_nbd,
403 (uint32_t)converted.radios[i].onTimeInMsForNanScan);
404 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time_gscan,
405 (uint32_t)converted.radios[i].onTimeInMsForBgScan);
406 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time_roam_scan,
407 (uint32_t)converted.radios[i].onTimeInMsForRoamScan);
408 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time_pno_scan,
409 (uint32_t)converted.radios[i].onTimeInMsForPnoScan);
410 EXPECT_EQ(legacy_ml_stats.radios[i].stats.on_time_hs20,
411 (uint32_t)converted.radios[i].onTimeInMsForHs20Scan);
412 EXPECT_EQ(legacy_ml_stats.radios[i].channel_stats.size(),
413 converted.radios[i].channelStats.size());
414 for (size_t k = 0; k < legacy_ml_stats.radios[i].channel_stats.size(); k++) {
415 auto& legacy_channel_st = legacy_ml_stats.radios[i].channel_stats[k];
416 EXPECT_EQ(WifiChannelWidthInMhz::WIDTH_20,
417 converted.radios[i].channelStats[k].channel.width);
418 EXPECT_EQ(legacy_channel_st.channel.center_freq,
419 converted.radios[i].channelStats[k].channel.centerFreq);
420 EXPECT_EQ(legacy_channel_st.channel.center_freq0,
421 converted.radios[i].channelStats[k].channel.centerFreq0);
422 EXPECT_EQ(legacy_channel_st.channel.center_freq1,
423 converted.radios[i].channelStats[k].channel.centerFreq1);
424 EXPECT_EQ(legacy_channel_st.cca_busy_time,
425 (uint32_t)converted.radios[i].channelStats[k].ccaBusyTimeInMs);
426 EXPECT_EQ(legacy_channel_st.on_time,
427 (uint32_t)converted.radios[i].channelStats[k].onTimeInMs);
428 }
429 }
430 }
431
TEST_F(AidlStructUtilTest,canConvertLegacyLinkLayerStatsToAidl)432 TEST_F(AidlStructUtilTest, canConvertLegacyLinkLayerStatsToAidl) {
433 legacy_hal::LinkLayerStats legacy_stats{};
434 legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
435 legacy_stats.radios.push_back(legacy_hal::LinkLayerRadioStats{});
436 legacy_stats.peers.push_back(legacy_hal::WifiPeerInfo{});
437 legacy_stats.peers.push_back(legacy_hal::WifiPeerInfo{});
438 legacy_stats.iface.beacon_rx = rand();
439 // RSSI: 0 to -127
440 legacy_stats.iface.rssi_mgmt = rand() % 128;
441 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu = rand();
442 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu = rand();
443 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost = rand();
444 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries = rand();
445 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min = rand();
446 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max = rand();
447 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg = rand();
448 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples = rand();
449
450 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu = rand();
451 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu = rand();
452 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost = rand();
453 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries = rand();
454 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min = rand();
455 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max = rand();
456 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg = rand();
457 legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples = rand();
458
459 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu = rand();
460 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu = rand();
461 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost = rand();
462 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries = rand();
463 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min = rand();
464 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max = rand();
465 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg = rand();
466 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples = rand();
467
468 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu = rand();
469 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu = rand();
470 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost = rand();
471 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries = rand();
472 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min = rand();
473 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max = rand();
474 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg = rand();
475 legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples = rand();
476
477 legacy_stats.iface.info.time_slicing_duty_cycle_percent = rand() % 101;
478 legacy_stats.iface.num_peers = 1;
479
480 for (auto& radio : legacy_stats.radios) {
481 // Max number of radios limit to 3.
482 radio.stats.radio = rand() % 4;
483 radio.stats.on_time = rand();
484 radio.stats.tx_time = rand();
485 radio.stats.rx_time = rand();
486 radio.stats.on_time_scan = rand();
487 radio.stats.on_time_nbd = rand();
488 radio.stats.on_time_gscan = rand();
489 radio.stats.on_time_roam_scan = rand();
490 radio.stats.on_time_pno_scan = rand();
491 radio.stats.on_time_hs20 = rand();
492 for (int i = 0; i < 4; i++) {
493 radio.tx_time_per_levels.push_back(rand());
494 }
495
496 legacy_hal::wifi_channel_stat channel_stat1 = {
497 .channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 2437, 2437, 0},
498 .on_time = 0x1111,
499 .cca_busy_time = 0x55,
500 };
501 legacy_hal::wifi_channel_stat channel_stat2 = {
502 .channel = {legacy_hal::WIFI_CHAN_WIDTH_20, 5180, 5180, 0},
503 .on_time = 0x2222,
504 .cca_busy_time = 0x66,
505 };
506 radio.channel_stats.push_back(channel_stat1);
507 radio.channel_stats.push_back(channel_stat2);
508 }
509
510 for (auto& peer : legacy_stats.peers) {
511 // Max number of stations is limited to 32 for testing.
512 peer.peer_info.bssload.sta_count = rand() % 33;
513 peer.peer_info.bssload.chan_util = rand() % 101;
514 wifi_rate_stat rate_stat1 = {
515 .rate = {3, 1, 2, 5, 0, 0},
516 .tx_mpdu = 0,
517 .rx_mpdu = 1,
518 .mpdu_lost = 2,
519 .retries = 3,
520 .retries_short = 4,
521 .retries_long = 5,
522 };
523 wifi_rate_stat rate_stat2 = {
524 .rate = {2, 2, 1, 6, 0, 1},
525 .tx_mpdu = 6,
526 .rx_mpdu = 7,
527 .mpdu_lost = 8,
528 .retries = 9,
529 .retries_short = 10,
530 .retries_long = 11,
531 };
532 peer.rate_stats.push_back(rate_stat1);
533 peer.rate_stats.push_back(rate_stat2);
534 }
535
536 StaLinkLayerStats converted{};
537 aidl_struct_util::convertLegacyLinkLayerStatsToAidl(legacy_stats, &converted);
538 EXPECT_EQ(0, converted.iface.links[0].linkId);
539 EXPECT_EQ(legacy_stats.iface.beacon_rx, (uint32_t)converted.iface.links[0].beaconRx);
540 EXPECT_EQ(legacy_stats.iface.rssi_mgmt, converted.iface.links[0].avgRssiMgmt);
541 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu,
542 converted.iface.links[0].wmeBePktStats.rxMpdu);
543 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu,
544 converted.iface.links[0].wmeBePktStats.txMpdu);
545 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost,
546 converted.iface.links[0].wmeBePktStats.lostMpdu);
547 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries,
548 converted.iface.links[0].wmeBePktStats.retries);
549 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_min,
550 (uint32_t)converted.iface.links[0].wmeBeContentionTimeStats.contentionTimeMinInUsec);
551 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_max,
552 (uint32_t)converted.iface.links[0].wmeBeContentionTimeStats.contentionTimeMaxInUsec);
553 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_time_avg,
554 (uint32_t)converted.iface.links[0].wmeBeContentionTimeStats.contentionTimeAvgInUsec);
555 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].contention_num_samples,
556 (uint32_t)converted.iface.links[0].wmeBeContentionTimeStats.contentionNumSamples);
557
558 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu,
559 converted.iface.links[0].wmeBkPktStats.rxMpdu);
560 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu,
561 converted.iface.links[0].wmeBkPktStats.txMpdu);
562 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost,
563 converted.iface.links[0].wmeBkPktStats.lostMpdu);
564 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries,
565 converted.iface.links[0].wmeBkPktStats.retries);
566 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_min,
567 (uint32_t)converted.iface.links[0].wmeBkContentionTimeStats.contentionTimeMinInUsec);
568 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_max,
569 (uint32_t)converted.iface.links[0].wmeBkContentionTimeStats.contentionTimeMaxInUsec);
570 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_time_avg,
571 (uint32_t)converted.iface.links[0].wmeBkContentionTimeStats.contentionTimeAvgInUsec);
572 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].contention_num_samples,
573 (uint32_t)converted.iface.links[0].wmeBkContentionTimeStats.contentionNumSamples);
574
575 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu,
576 converted.iface.links[0].wmeViPktStats.rxMpdu);
577 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu,
578 converted.iface.links[0].wmeViPktStats.txMpdu);
579 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost,
580 converted.iface.links[0].wmeViPktStats.lostMpdu);
581 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries,
582 converted.iface.links[0].wmeViPktStats.retries);
583 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_min,
584 (uint32_t)converted.iface.links[0].wmeViContentionTimeStats.contentionTimeMinInUsec);
585 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_max,
586 (uint32_t)converted.iface.links[0].wmeViContentionTimeStats.contentionTimeMaxInUsec);
587 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_time_avg,
588 (uint32_t)converted.iface.links[0].wmeViContentionTimeStats.contentionTimeAvgInUsec);
589 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].contention_num_samples,
590 (uint32_t)converted.iface.links[0].wmeViContentionTimeStats.contentionNumSamples);
591
592 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu,
593 converted.iface.links[0].wmeVoPktStats.rxMpdu);
594 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu,
595 converted.iface.links[0].wmeVoPktStats.txMpdu);
596 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost,
597 converted.iface.links[0].wmeVoPktStats.lostMpdu);
598 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries,
599 converted.iface.links[0].wmeVoPktStats.retries);
600 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_min,
601 (uint32_t)converted.iface.links[0].wmeVoContentionTimeStats.contentionTimeMinInUsec);
602 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_max,
603 (uint32_t)converted.iface.links[0].wmeVoContentionTimeStats.contentionTimeMaxInUsec);
604 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_time_avg,
605 (uint32_t)converted.iface.links[0].wmeVoContentionTimeStats.contentionTimeAvgInUsec);
606 EXPECT_EQ(legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].contention_num_samples,
607 (uint32_t)converted.iface.links[0].wmeVoContentionTimeStats.contentionNumSamples);
608
609 EXPECT_EQ(legacy_stats.iface.info.time_slicing_duty_cycle_percent,
610 converted.iface.links[0].timeSliceDutyCycleInPercent);
611
612 EXPECT_EQ(legacy_stats.radios.size(), converted.radios.size());
613 for (size_t i = 0; i < legacy_stats.radios.size(); i++) {
614 EXPECT_EQ(legacy_stats.radios[i].stats.radio, converted.radios[i].radioId);
615 EXPECT_EQ(legacy_stats.radios[i].stats.on_time, (uint32_t)converted.radios[i].onTimeInMs);
616 EXPECT_EQ(legacy_stats.radios[i].stats.tx_time, (uint32_t)converted.radios[i].txTimeInMs);
617 EXPECT_EQ(legacy_stats.radios[i].stats.rx_time, (uint32_t)converted.radios[i].rxTimeInMs);
618 EXPECT_EQ(legacy_stats.radios[i].stats.on_time_scan,
619 (uint32_t)converted.radios[i].onTimeInMsForScan);
620 EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels.size(),
621 converted.radios[i].txTimeInMsPerLevel.size());
622 for (size_t j = 0; j < legacy_stats.radios[i].tx_time_per_levels.size(); j++) {
623 EXPECT_EQ(legacy_stats.radios[i].tx_time_per_levels[j],
624 (uint32_t)converted.radios[i].txTimeInMsPerLevel[j]);
625 }
626 EXPECT_EQ(legacy_stats.radios[i].stats.on_time_nbd,
627 (uint32_t)converted.radios[i].onTimeInMsForNanScan);
628 EXPECT_EQ(legacy_stats.radios[i].stats.on_time_gscan,
629 (uint32_t)converted.radios[i].onTimeInMsForBgScan);
630 EXPECT_EQ(legacy_stats.radios[i].stats.on_time_roam_scan,
631 (uint32_t)converted.radios[i].onTimeInMsForRoamScan);
632 EXPECT_EQ(legacy_stats.radios[i].stats.on_time_pno_scan,
633 (uint32_t)converted.radios[i].onTimeInMsForPnoScan);
634 EXPECT_EQ(legacy_stats.radios[i].stats.on_time_hs20,
635 (uint32_t)converted.radios[i].onTimeInMsForHs20Scan);
636 EXPECT_EQ(legacy_stats.radios[i].channel_stats.size(),
637 converted.radios[i].channelStats.size());
638 for (size_t k = 0; k < legacy_stats.radios[i].channel_stats.size(); k++) {
639 auto& legacy_channel_st = legacy_stats.radios[i].channel_stats[k];
640 EXPECT_EQ(WifiChannelWidthInMhz::WIDTH_20,
641 converted.radios[i].channelStats[k].channel.width);
642 EXPECT_EQ(legacy_channel_st.channel.center_freq,
643 converted.radios[i].channelStats[k].channel.centerFreq);
644 EXPECT_EQ(legacy_channel_st.channel.center_freq0,
645 converted.radios[i].channelStats[k].channel.centerFreq0);
646 EXPECT_EQ(legacy_channel_st.channel.center_freq1,
647 converted.radios[i].channelStats[k].channel.centerFreq1);
648 EXPECT_EQ(legacy_channel_st.cca_busy_time,
649 (uint32_t)converted.radios[i].channelStats[k].ccaBusyTimeInMs);
650 EXPECT_EQ(legacy_channel_st.on_time,
651 (uint32_t)converted.radios[i].channelStats[k].onTimeInMs);
652 }
653 }
654
655 EXPECT_EQ(legacy_stats.peers.size(), converted.iface.links[0].peers.size());
656 for (size_t i = 0; i < legacy_stats.peers.size(); i++) {
657 EXPECT_EQ(legacy_stats.peers[i].peer_info.bssload.sta_count,
658 converted.iface.links[0].peers[i].staCount);
659 EXPECT_EQ(legacy_stats.peers[i].peer_info.bssload.chan_util,
660 converted.iface.links[0].peers[i].chanUtil);
661 for (size_t j = 0; j < legacy_stats.peers[i].rate_stats.size(); j++) {
662 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.preamble,
663 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].rateInfo.preamble);
664 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.nss,
665 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].rateInfo.nss);
666 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.bw,
667 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].rateInfo.bw);
668 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rate.rateMcsIdx,
669 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].rateInfo.rateMcsIdx);
670 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].tx_mpdu,
671 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].txMpdu);
672 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].rx_mpdu,
673 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].rxMpdu);
674 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].mpdu_lost,
675 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].mpduLost);
676 EXPECT_EQ(legacy_stats.peers[i].rate_stats[j].retries,
677 (uint32_t)converted.iface.links[0].peers[i].rateStats[j].retries);
678 }
679 }
680 }
681
TEST_F(AidlStructUtilTest,CanConvertLegacyFeaturesToAidl)682 TEST_F(AidlStructUtilTest, CanConvertLegacyFeaturesToAidl) {
683 using AidlChipCaps = IWifiChip::FeatureSetMask;
684
685 uint32_t aidl_features;
686 uint32_t legacy_feature_set = WIFI_FEATURE_D2D_RTT | WIFI_FEATURE_SET_LATENCY_MODE;
687
688 ASSERT_TRUE(
689 aidl_struct_util::convertLegacyChipFeaturesToAidl(legacy_feature_set, &aidl_features));
690
691 EXPECT_EQ((uint32_t)AidlChipCaps::D2D_RTT | (uint32_t)AidlChipCaps::SET_LATENCY_MODE,
692 aidl_features);
693 }
694
insertRadioCombination(legacy_hal::wifi_radio_combination * dst_radio_combination_ptr,int num_radio_configurations,legacy_hal::wifi_radio_configuration * radio_configuration)695 void insertRadioCombination(legacy_hal::wifi_radio_combination* dst_radio_combination_ptr,
696 int num_radio_configurations,
697 legacy_hal::wifi_radio_configuration* radio_configuration) {
698 dst_radio_combination_ptr->num_radio_configurations = num_radio_configurations;
699 memcpy(dst_radio_combination_ptr->radio_configurations, radio_configuration,
700 num_radio_configurations * sizeof(legacy_hal::wifi_radio_configuration));
701 }
702
verifyRadioCombination(WifiRadioCombination * radioCombination,size_t num_radio_configurations,legacy_hal::wifi_radio_configuration * radio_configuration)703 void verifyRadioCombination(WifiRadioCombination* radioCombination, size_t num_radio_configurations,
704 legacy_hal::wifi_radio_configuration* radio_configuration) {
705 EXPECT_EQ(num_radio_configurations, radioCombination->radioConfigurations.size());
706 for (size_t i = 0; i < num_radio_configurations; i++) {
707 EXPECT_EQ(aidl_struct_util::convertLegacyMacBandToAidlWifiBand(radio_configuration->band),
708 radioCombination->radioConfigurations[i].bandInfo);
709 EXPECT_EQ(aidl_struct_util::convertLegacyAntennaConfigurationToAidl(
710 radio_configuration->antenna_cfg),
711 radioCombination->radioConfigurations[i].antennaMode);
712 radio_configuration++;
713 }
714 }
715
TEST_F(AidlStructUtilTest,canConvertLegacyRadioCombinationsMatrixToAidl)716 TEST_F(AidlStructUtilTest, canConvertLegacyRadioCombinationsMatrixToAidl) {
717 legacy_hal::wifi_radio_configuration radio_configurations_array1[] = {
718 {.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_1X1},
719 };
720 legacy_hal::wifi_radio_configuration radio_configurations_array2[] = {
721 {.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_2X2},
722 {.band = legacy_hal::WLAN_MAC_5_0_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_3X3},
723 };
724 legacy_hal::wifi_radio_configuration radio_configurations_array3[] = {
725 {.band = legacy_hal::WLAN_MAC_2_4_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_2X2},
726 {.band = legacy_hal::WLAN_MAC_6_0_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_1X1},
727 {.band = legacy_hal::WLAN_MAC_5_0_BAND, .antenna_cfg = legacy_hal::WIFI_ANTENNA_4X4},
728 };
729
730 int num_radio_configs = 0;
731 int num_combinations = 0;
732 std::array<char, 256> buffer;
733 buffer.fill(0);
734 legacy_hal::wifi_radio_combination_matrix* legacy_matrix =
735 reinterpret_cast<wifi_radio_combination_matrix*>(buffer.data());
736 legacy_hal::wifi_radio_combination* radio_combinations;
737
738 // Prepare a legacy wifi_radio_combination_matrix
739 legacy_matrix->num_radio_combinations = 3;
740 // Insert first combination
741 radio_combinations =
742 (legacy_hal::wifi_radio_combination*)((char*)legacy_matrix->radio_combinations);
743 insertRadioCombination(
744 radio_combinations,
745 sizeof(radio_configurations_array1) / sizeof(radio_configurations_array1[0]),
746 radio_configurations_array1);
747 num_combinations++;
748 num_radio_configs +=
749 sizeof(radio_configurations_array1) / sizeof(radio_configurations_array1[0]);
750
751 // Insert second combination
752 radio_combinations =
753 (legacy_hal::wifi_radio_combination*)((char*)legacy_matrix->radio_combinations +
754 (num_combinations *
755 sizeof(legacy_hal::wifi_radio_combination)) +
756 (num_radio_configs *
757 sizeof(wifi_radio_configuration)));
758 insertRadioCombination(
759 radio_combinations,
760 sizeof(radio_configurations_array2) / sizeof(radio_configurations_array2[0]),
761 radio_configurations_array2);
762 num_combinations++;
763 num_radio_configs +=
764 sizeof(radio_configurations_array2) / sizeof(radio_configurations_array2[0]);
765
766 // Insert third combination
767 radio_combinations =
768 (legacy_hal::wifi_radio_combination*)((char*)legacy_matrix->radio_combinations +
769 (num_combinations *
770 sizeof(legacy_hal::wifi_radio_combination)) +
771 (num_radio_configs *
772 sizeof(wifi_radio_configuration)));
773 insertRadioCombination(
774 radio_combinations,
775 sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
776 radio_configurations_array3);
777
778 std::vector<WifiRadioCombination> converted_combinations;
779 aidl_struct_util::convertLegacyRadioCombinationsMatrixToAidl(legacy_matrix,
780 &converted_combinations);
781
782 // Verify the conversion
783 EXPECT_EQ(legacy_matrix->num_radio_combinations, converted_combinations.size());
784 verifyRadioCombination(
785 &converted_combinations[0],
786 sizeof(radio_configurations_array1) / sizeof(radio_configurations_array1[0]),
787 radio_configurations_array1);
788 verifyRadioCombination(
789 &converted_combinations[1],
790 sizeof(radio_configurations_array2) / sizeof(radio_configurations_array2[0]),
791 radio_configurations_array2);
792 verifyRadioCombination(
793 &converted_combinations[2],
794 sizeof(radio_configurations_array3) / sizeof(radio_configurations_array3[0]),
795 radio_configurations_array3);
796 }
797
verifyRttResult(wifi_rtt_result * legacy_rtt_result_ptr,RttResult * aidl_results_ptr)798 void verifyRttResult(wifi_rtt_result* legacy_rtt_result_ptr, RttResult* aidl_results_ptr) {
799 EXPECT_EQ((int)legacy_rtt_result_ptr->burst_num, aidl_results_ptr->burstNum);
800 EXPECT_EQ((int)legacy_rtt_result_ptr->measurement_number, aidl_results_ptr->measurementNumber);
801 EXPECT_EQ((int)legacy_rtt_result_ptr->success_number, aidl_results_ptr->successNumber);
802 EXPECT_EQ(legacy_rtt_result_ptr->number_per_burst_peer, aidl_results_ptr->numberPerBurstPeer);
803 EXPECT_EQ(legacy_rtt_result_ptr->retry_after_duration, aidl_results_ptr->retryAfterDuration);
804 EXPECT_EQ(legacy_rtt_result_ptr->rssi, aidl_results_ptr->rssi);
805 EXPECT_EQ(legacy_rtt_result_ptr->rssi_spread, aidl_results_ptr->rssiSpread);
806 EXPECT_EQ(legacy_rtt_result_ptr->rtt, aidl_results_ptr->rtt);
807 EXPECT_EQ(legacy_rtt_result_ptr->rtt_sd, aidl_results_ptr->rttSd);
808 EXPECT_EQ(legacy_rtt_result_ptr->rtt_spread, aidl_results_ptr->rttSpread);
809 EXPECT_EQ(legacy_rtt_result_ptr->distance_mm, aidl_results_ptr->distanceInMm);
810 EXPECT_EQ(legacy_rtt_result_ptr->distance_sd_mm, aidl_results_ptr->distanceSdInMm);
811 EXPECT_EQ(legacy_rtt_result_ptr->distance_spread_mm, aidl_results_ptr->distanceSpreadInMm);
812 EXPECT_EQ(legacy_rtt_result_ptr->ts, aidl_results_ptr->timeStampInUs);
813 EXPECT_EQ(legacy_rtt_result_ptr->burst_duration, aidl_results_ptr->burstDurationInMs);
814 EXPECT_EQ(legacy_rtt_result_ptr->negotiated_burst_num, aidl_results_ptr->negotiatedBurstNum);
815 EXPECT_EQ(legacy_rtt_result_ptr->LCI->id, aidl_results_ptr->lci.id);
816 for (int i = 0; i < legacy_rtt_result_ptr->LCI->len; i++) {
817 EXPECT_EQ(legacy_rtt_result_ptr->LCI->data[i], aidl_results_ptr->lci.data[i]);
818 }
819 EXPECT_EQ(legacy_rtt_result_ptr->LCR->id, aidl_results_ptr->lcr.id);
820 for (int i = 0; i < legacy_rtt_result_ptr->LCR->len; i++) {
821 EXPECT_EQ(legacy_rtt_result_ptr->LCR->data[i], aidl_results_ptr->lcr.data[i]);
822 }
823 }
824
fillLegacyRttResult(wifi_rtt_result * rtt_result_ptr)825 void fillLegacyRttResult(wifi_rtt_result* rtt_result_ptr) {
826 std::copy(std::begin(kMacAddress), std::end(kMacAddress), std::begin(rtt_result_ptr->addr));
827 rtt_result_ptr->burst_num = rand();
828 rtt_result_ptr->measurement_number = rand();
829 rtt_result_ptr->success_number = rand();
830 rtt_result_ptr->number_per_burst_peer = 0xF & rand();
831 rtt_result_ptr->status = RTT_STATUS_SUCCESS;
832 rtt_result_ptr->retry_after_duration = 0xF & rand();
833 rtt_result_ptr->type = RTT_TYPE_2_SIDED;
834 rtt_result_ptr->rssi = rand();
835 rtt_result_ptr->rssi_spread = rand();
836 rtt_result_ptr->rtt = rand();
837 rtt_result_ptr->rtt_sd = rand();
838 rtt_result_ptr->rtt_spread = rand();
839 rtt_result_ptr->distance_mm = rand();
840 rtt_result_ptr->distance_sd_mm = rand();
841 rtt_result_ptr->distance_spread_mm = rand();
842 rtt_result_ptr->burst_duration = rand();
843 rtt_result_ptr->negotiated_burst_num = rand();
844 rtt_result_ptr->LCI = (wifi_information_element*)LCI;
845 rtt_result_ptr->LCR = (wifi_information_element*)LCR;
846 }
847
TEST_F(AidlStructUtilTest,convertLegacyVectorOfRttResultToAidl)848 TEST_F(AidlStructUtilTest, convertLegacyVectorOfRttResultToAidl) {
849 std::vector<const wifi_rtt_result*> rtt_results_vec;
850 wifi_rtt_result rttResults[2];
851
852 // fill legacy rtt results
853 for (int i = 0; i < 2; i++) {
854 fillLegacyRttResult(&rttResults[i]);
855 rtt_results_vec.push_back(&rttResults[i]);
856 }
857
858 std::vector<RttResult> aidl_results;
859 aidl_struct_util::convertLegacyVectorOfRttResultToAidl(rtt_results_vec, &aidl_results);
860
861 EXPECT_EQ(rtt_results_vec.size(), aidl_results.size());
862 for (size_t i = 0; i < rtt_results_vec.size(); i++) {
863 verifyRttResult(&rttResults[i], &aidl_results[i]);
864 EXPECT_EQ(aidl_results[i].channelFreqMHz, 0);
865 EXPECT_EQ(aidl_results[i].packetBw, RttBw::BW_UNSPECIFIED);
866 }
867 }
868
TEST_F(AidlStructUtilTest,convertLegacyVectorOfRttResultV2ToAidl)869 TEST_F(AidlStructUtilTest, convertLegacyVectorOfRttResultV2ToAidl) {
870 std::vector<const wifi_rtt_result_v2*> rtt_results_vec_v2;
871 wifi_rtt_result_v2 rttResults_v2[2];
872
873 // fill legacy rtt results v2
874 for (int i = 0; i < 2; i++) {
875 fillLegacyRttResult(&rttResults_v2[i].rtt_result);
876 rttResults_v2[i].frequency = 2412 + i * 5;
877 rttResults_v2[i].packet_bw = WIFI_RTT_BW_80;
878 rtt_results_vec_v2.push_back(&rttResults_v2[i]);
879 }
880
881 std::vector<RttResult> aidl_results;
882 aidl_struct_util::convertLegacyVectorOfRttResultV2ToAidl(rtt_results_vec_v2, &aidl_results);
883
884 EXPECT_EQ(rtt_results_vec_v2.size(), aidl_results.size());
885 for (size_t i = 0; i < rtt_results_vec_v2.size(); i++) {
886 verifyRttResult(&rttResults_v2[i].rtt_result, &aidl_results[i]);
887 EXPECT_EQ(aidl_results[i].channelFreqMHz, rttResults_v2[i].frequency);
888 EXPECT_EQ(aidl_results[i].packetBw, RttBw::BW_80MHZ);
889 }
890 }
891
TEST_F(AidlStructUtilTest,convertCachedScanReportToAidl)892 TEST_F(AidlStructUtilTest, convertCachedScanReportToAidl) {
893 legacy_hal::WifiCachedScanReport hw_report;
894
895 hw_report.ts = 10000000;
896 std::vector<int> scanned_freqs{5260, 2437, 5200};
897 std::vector<wifi_cached_scan_result> results;
898 hw_report.scanned_freqs = scanned_freqs;
899
900 for (int i = 0; i < kNumScanResult; i++) {
901 wifi_cached_scan_result result;
902 result.age_ms = i * 1000;
903 result.capability = i;
904 memcpy(result.ssid, kSsid, kSsidLen);
905 result.ssid_len = kSsidLen;
906 memcpy(result.bssid, kBssid, 6);
907 result.flags = WIFI_CACHED_SCAN_RESULT_FLAGS_HE_OPS_PRESENT;
908 result.rssi = kRssi[i];
909 result.chanspec = {legacy_hal::WIFI_CHAN_WIDTH_40, 0, 0, i};
910 results.push_back(result);
911 }
912 hw_report.results = results;
913
914 CachedScanData aidl_data;
915 aidl_struct_util::convertCachedScanReportToAidl(hw_report, &aidl_data);
916
917 EXPECT_EQ(scanned_freqs.size(), aidl_data.scannedFrequenciesMhz.size());
918 EXPECT_EQ(scanned_freqs[2], aidl_data.scannedFrequenciesMhz[2]);
919 EXPECT_EQ(5260, aidl_data.scannedFrequenciesMhz[0]);
920 EXPECT_EQ(kNumScanResult, (int)aidl_data.cachedScanResults.size());
921 for (int i = 0; i < kNumScanResult; i++) {
922 EXPECT_EQ(hw_report.results[i].rssi, aidl_data.cachedScanResults[i].rssiDbm);
923 EXPECT_EQ(i, aidl_data.cachedScanResults[i].frequencyMhz);
924 int64_t expected_ts = 10000000 - i * 1000 * 1000;
925 EXPECT_EQ(expected_ts, aidl_data.cachedScanResults[i].timeStampInUs);
926 EXPECT_EQ(WifiRatePreamble::HE, aidl_data.cachedScanResults[i].preambleType);
927 EXPECT_EQ(WifiChannelWidthInMhz::WIDTH_40, aidl_data.cachedScanResults[i].channelWidthMhz);
928 for (int k = 0; k < 6; k++) {
929 EXPECT_EQ(kBssid[k], aidl_data.cachedScanResults[i].bssid[k]);
930 }
931 for (int k = 0; k < kSsidLen; k++) {
932 EXPECT_EQ(kSsid[k], aidl_data.cachedScanResults[i].ssid[k]);
933 }
934 }
935 }
936
937 } // namespace wifi
938 } // namespace hardware
939 } // namespace android
940 } // namespace aidl
941