1 /*
2 * Copyright (c) 2019, The OpenThread Authors.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. Neither the name of the copyright holder nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <string.h>
30
31 #include "dbus/common/dbus_message_helper.hpp"
32
33 #include <CppUTest/TestHarness.h>
34
35 using std::array;
36 using std::string;
37 using std::tuple;
38 using std::vector;
39
40 using otbr::DBus::DBusMessageEncode;
41 using otbr::DBus::DBusMessageExtract;
42 using otbr::DBus::DBusMessageToTuple;
43 using otbr::DBus::TupleToDBusMessage;
44
45 struct TestStruct
46 {
47 uint8_t tag;
48 uint32_t val;
49 std::string name;
50 };
51
52 namespace otbr {
53 namespace DBus {
54 template <> struct DBusTypeTrait<TestStruct>
55 {
56 static constexpr const char *TYPE_AS_STRING =
57 //{uint8, uint32, string}
58 "(yus)";
59 };
60 } // namespace DBus
61 } // namespace otbr
62
operator ==(const TestStruct & aLhs,const TestStruct & aRhs)63 bool operator==(const TestStruct &aLhs, const TestStruct &aRhs)
64 {
65 return aLhs.tag == aRhs.tag && aLhs.val == aRhs.val && aLhs.name == aRhs.name;
66 }
67
operator ==(const otbr::DBus::ChannelQuality & aLhs,const otbr::DBus::ChannelQuality & aRhs)68 bool operator==(const otbr::DBus::ChannelQuality &aLhs, const otbr::DBus::ChannelQuality &aRhs)
69 {
70 return aLhs.mChannel == aRhs.mChannel && aLhs.mOccupancy == aRhs.mOccupancy;
71 }
72
operator ==(const otbr::DBus::ChildInfo & aLhs,const otbr::DBus::ChildInfo & aRhs)73 bool operator==(const otbr::DBus::ChildInfo &aLhs, const otbr::DBus::ChildInfo &aRhs)
74 {
75 return aLhs.mExtAddress == aRhs.mExtAddress && aLhs.mTimeout == aRhs.mTimeout && aLhs.mAge == aRhs.mAge &&
76 aLhs.mRloc16 == aRhs.mRloc16 && aLhs.mChildId == aRhs.mChildId &&
77 aLhs.mNetworkDataVersion == aRhs.mNetworkDataVersion && aLhs.mLinkQualityIn == aRhs.mLinkQualityIn &&
78 aLhs.mAverageRssi == aRhs.mAverageRssi && aLhs.mLastRssi == aRhs.mLastRssi &&
79 aLhs.mFrameErrorRate == aRhs.mFrameErrorRate && aLhs.mMessageErrorRate == aRhs.mMessageErrorRate &&
80 aLhs.mRxOnWhenIdle == aRhs.mRxOnWhenIdle && aLhs.mFullThreadDevice == aRhs.mFullThreadDevice &&
81 aLhs.mFullNetworkData == aRhs.mFullNetworkData && aLhs.mIsStateRestoring == aRhs.mIsStateRestoring;
82 }
83
operator ==(const otbr::DBus::NeighborInfo & aLhs,const otbr::DBus::NeighborInfo & aRhs)84 bool operator==(const otbr::DBus::NeighborInfo &aLhs, const otbr::DBus::NeighborInfo &aRhs)
85 {
86 return aLhs.mExtAddress == aRhs.mExtAddress && aLhs.mAge == aRhs.mAge && aLhs.mRloc16 == aRhs.mRloc16 &&
87 aLhs.mLinkFrameCounter == aRhs.mLinkFrameCounter && aLhs.mMleFrameCounter == aRhs.mMleFrameCounter &&
88 aLhs.mLinkQualityIn == aRhs.mLinkQualityIn && aLhs.mAverageRssi == aRhs.mAverageRssi &&
89 aLhs.mLastRssi == aRhs.mLastRssi && aLhs.mFrameErrorRate == aRhs.mFrameErrorRate &&
90 aLhs.mMessageErrorRate == aRhs.mMessageErrorRate && aLhs.mRxOnWhenIdle == aRhs.mRxOnWhenIdle &&
91 aLhs.mFullThreadDevice == aRhs.mFullThreadDevice && aLhs.mFullNetworkData == aRhs.mFullNetworkData &&
92 aLhs.mIsChild == aRhs.mIsChild;
93 }
94
operator ==(const otbr::DBus::LeaderData & aLhs,const otbr::DBus::LeaderData & aRhs)95 bool operator==(const otbr::DBus::LeaderData &aLhs, const otbr::DBus::LeaderData &aRhs)
96 {
97 return aLhs.mPartitionId == aRhs.mPartitionId && aLhs.mWeighting == aRhs.mWeighting &&
98 aLhs.mDataVersion == aRhs.mDataVersion && aLhs.mStableDataVersion == aRhs.mStableDataVersion &&
99 aLhs.mLeaderRouterId == aRhs.mLeaderRouterId;
100 }
101
operator ==(const otbr::DBus::ActiveScanResult & aLhs,const otbr::DBus::ActiveScanResult & aRhs)102 bool operator==(const otbr::DBus::ActiveScanResult &aLhs, const otbr::DBus::ActiveScanResult &aRhs)
103 {
104 return aLhs.mExtAddress == aRhs.mExtAddress && aLhs.mNetworkName == aRhs.mNetworkName &&
105 aLhs.mExtendedPanId == aRhs.mExtendedPanId && aLhs.mSteeringData == aRhs.mSteeringData &&
106 aLhs.mPanId == aRhs.mPanId && aLhs.mJoinerUdpPort == aRhs.mJoinerUdpPort && aLhs.mChannel == aRhs.mChannel &&
107 aLhs.mRssi == aRhs.mRssi && aLhs.mLqi == aRhs.mLqi && aLhs.mVersion == aRhs.mVersion &&
108 aLhs.mIsNative == aRhs.mIsNative;
109 }
110
operator ==(const otbr::DBus::Ip6Prefix & aLhs,const otbr::DBus::Ip6Prefix & aRhs)111 bool operator==(const otbr::DBus::Ip6Prefix &aLhs, const otbr::DBus::Ip6Prefix &aRhs)
112 {
113 bool prefixDataEquality = (aLhs.mPrefix.size() == aRhs.mPrefix.size()) &&
114 (memcmp(&aLhs.mPrefix[0], &aRhs.mPrefix[0], aLhs.mPrefix.size()) == 0);
115
116 return prefixDataEquality && aLhs.mLength == aRhs.mLength;
117 }
118
operator ==(const otbr::DBus::ExternalRoute & aLhs,const otbr::DBus::ExternalRoute & aRhs)119 bool operator==(const otbr::DBus::ExternalRoute &aLhs, const otbr::DBus::ExternalRoute &aRhs)
120 {
121 return aLhs.mPrefix == aRhs.mPrefix && aLhs.mRloc16 == aRhs.mRloc16 && aLhs.mPreference == aRhs.mPreference &&
122 aLhs.mStable == aRhs.mStable && aLhs.mNextHopIsThisDevice == aRhs.mNextHopIsThisDevice;
123 }
124
DBusMessageEncode(DBusMessageIter * aIter,const TestStruct & aValue)125 inline otbrError DBusMessageEncode(DBusMessageIter *aIter, const TestStruct &aValue)
126 {
127 otbrError error = OTBR_ERROR_DBUS;
128 DBusMessageIter sub;
129 VerifyOrExit(dbus_message_iter_open_container(aIter, DBUS_TYPE_STRUCT, nullptr, &sub), error = OTBR_ERROR_DBUS);
130
131 SuccessOrExit(DBusMessageEncode(&sub, aValue.tag));
132 SuccessOrExit(DBusMessageEncode(&sub, aValue.val));
133 SuccessOrExit(DBusMessageEncode(&sub, aValue.name));
134 VerifyOrExit(dbus_message_iter_close_container(aIter, &sub), error = OTBR_ERROR_DBUS);
135 error = OTBR_ERROR_NONE;
136
137 exit:
138 return error;
139 }
140
DBusMessageExtract(DBusMessageIter * aIter,TestStruct & aValue)141 inline otbrError DBusMessageExtract(DBusMessageIter *aIter, TestStruct &aValue)
142 {
143 otbrError error = OTBR_ERROR_DBUS;
144 DBusMessageIter sub;
145
146 VerifyOrExit(dbus_message_iter_get_arg_type(aIter) == DBUS_TYPE_STRUCT, error = OTBR_ERROR_DBUS);
147 dbus_message_iter_recurse(aIter, &sub);
148 SuccessOrExit(DBusMessageExtract(&sub, aValue.tag));
149 SuccessOrExit(DBusMessageExtract(&sub, aValue.val));
150 SuccessOrExit(DBusMessageExtract(&sub, aValue.name));
151
152 dbus_message_iter_next(aIter);
153 error = OTBR_ERROR_NONE;
154
155 exit:
156 return error;
157 }
158
TEST_GROUP(DBusMessage)159 TEST_GROUP(DBusMessage){};
160
TEST(DBusMessage,TestVectorMessage)161 TEST(DBusMessage, TestVectorMessage)
162 {
163 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
164 tuple<vector<uint8_t>, vector<uint16_t>, vector<uint32_t>, vector<uint64_t>, vector<int16_t>, vector<int32_t>,
165 vector<int64_t>>
166 setVals({0, 1}, {2, 3}, {4, 5}, {6, 7, 8}, {}, {9, 10}, {11, 12});
167
168 tuple<vector<uint8_t>, vector<uint16_t>, vector<uint32_t>, vector<uint64_t>, vector<int16_t>, vector<int32_t>,
169 vector<int64_t>>
170 getVals({}, {}, {}, {}, {}, {}, {});
171 CHECK(msg != nullptr);
172
173 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
174 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
175
176 CHECK(setVals == getVals);
177
178 dbus_message_unref(msg);
179 }
180
TEST(DBusMessage,TestArrayMessage)181 TEST(DBusMessage, TestArrayMessage)
182 {
183 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
184 tuple<array<uint8_t, 4>> setVals({1, 2, 3, 4});
185 tuple<array<uint8_t, 4>> getVals({0, 0, 0, 0});
186
187 CHECK(msg != nullptr);
188
189 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
190 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
191
192 CHECK(setVals == getVals);
193
194 dbus_message_unref(msg);
195 }
196
TEST(DBusMessage,TestNumberMessage)197 TEST(DBusMessage, TestNumberMessage)
198 {
199 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
200 tuple<uint8_t, uint16_t, uint32_t, uint64_t, bool, int16_t, int32_t, int64_t> setVals =
201 std::make_tuple<uint8_t, uint16_t, uint32_t, uint64_t, bool, int16_t, int32_t, int64_t>(1, 2, 3, 4, true, 5, 6,
202 7);
203 tuple<uint8_t, uint16_t, uint32_t, uint64_t, bool, int16_t, int32_t, int64_t> getVals =
204 std::make_tuple<uint8_t, uint16_t, uint32_t, uint64_t, bool, int16_t, int32_t, int64_t>(0, 0, 0, 0, false, 0, 0,
205 0);
206
207 CHECK(msg != nullptr);
208
209 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
210 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
211
212 CHECK(setVals == getVals);
213
214 dbus_message_unref(msg);
215 }
216
TEST(DBusMessage,TestStructMessage)217 TEST(DBusMessage, TestStructMessage)
218 {
219 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
220 tuple<uint8_t, vector<int32_t>, vector<string>, vector<TestStruct>> setVals(
221 0x03, {0x04, 0x05}, {"hello", "world"}, {{1, 0xf0a, "test1"}, {2, 0xf0b, "test2"}});
222 tuple<uint8_t, vector<int32_t>, vector<string>, vector<TestStruct>> getVals(0, {}, {}, {});
223
224 CHECK(msg != nullptr);
225
226 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
227 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
228
229 CHECK(setVals == getVals);
230
231 dbus_message_unref(msg);
232 }
233
TEST(DBusMessage,TestOtbrChannelQuality)234 TEST(DBusMessage, TestOtbrChannelQuality)
235 {
236 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
237 tuple<std::vector<otbr::DBus::ChannelQuality>> setVals({{1, 2}});
238 tuple<std::vector<otbr::DBus::ChannelQuality>> getVals;
239
240 CHECK(msg != nullptr);
241
242 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
243 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
244
245 CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
246
247 dbus_message_unref(msg);
248 }
249
TEST(DBusMessage,TestOtbrChildInfo)250 TEST(DBusMessage, TestOtbrChildInfo)
251 {
252 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
253 tuple<std::vector<otbr::DBus::ChildInfo>> setVals({{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, true, false, true, false}});
254 tuple<std::vector<otbr::DBus::ChildInfo>> getVals;
255
256 CHECK(msg != nullptr);
257
258 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
259 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
260
261 CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
262
263 dbus_message_unref(msg);
264 }
265
TEST(DBusMessage,TestOtbrNeighborInfo)266 TEST(DBusMessage, TestOtbrNeighborInfo)
267 {
268 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
269 tuple<std::vector<otbr::DBus::NeighborInfo>> setVals(
270 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, true, false, true, false}});
271 tuple<std::vector<otbr::DBus::NeighborInfo>> getVals;
272
273 CHECK(msg != nullptr);
274
275 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
276 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
277
278 CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
279
280 dbus_message_unref(msg);
281 }
282
TEST(DBusMessage,TestOtbrLeaderData)283 TEST(DBusMessage, TestOtbrLeaderData)
284 {
285 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
286 tuple<std::vector<otbr::DBus::LeaderData>> setVals({{1, 2, 3, 4, 5}});
287 tuple<std::vector<otbr::DBus::LeaderData>> getVals;
288
289 CHECK(msg != nullptr);
290
291 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
292 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
293
294 CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
295
296 dbus_message_unref(msg);
297 }
298
TEST(DBusMessage,TestOtbrActiveScanResults)299 TEST(DBusMessage, TestOtbrActiveScanResults)
300 {
301 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
302 tuple<std::vector<otbr::DBus::ActiveScanResult>> setVals({{1, "a", 2, {3}, 4, 5, 6, 7, 8, 9, true, false}});
303 tuple<std::vector<otbr::DBus::ActiveScanResult>> getVals;
304
305 CHECK(msg != nullptr);
306
307 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
308 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
309
310 CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
311
312 dbus_message_unref(msg);
313 }
314
TEST(DBusMessage,TestOtbrExternalRoute)315 TEST(DBusMessage, TestOtbrExternalRoute)
316 {
317 DBusMessage *msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
318 tuple<std::vector<otbr::DBus::ExternalRoute>> setVals(
319 {{otbr::DBus::Ip6Prefix({{0xfa, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}, 64}), uint16_t(0xfc00), 1, true,
320 true}});
321 tuple<std::vector<otbr::DBus::ExternalRoute>> getVals;
322
323 CHECK(msg != nullptr);
324
325 CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
326 CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
327
328 CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
329
330 dbus_message_unref(msg);
331 }
332