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