third_party/ot-br-posix/repo/tests/unit/test_dbus_message.cpp

   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
  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
  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
  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
  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
  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
 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 && aLhs.mIsJoinable == aRhs.mIsJoinable;
 109 }
 110
 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
 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
 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
 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
 159 TEST_GROUP(DBusMessage){};
 160
 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
 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
 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
 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
 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
 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
 266 TEST(DBusMessage, TestOtbrNeighborInfo)
 267 {
 268     DBusMessage *                                msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
 269     tuple<std::vector<otbr::DBus::NeighborInfo>> setVals({{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, true, false, true, false}});
 270     tuple<std::vector<otbr::DBus::NeighborInfo>> getVals;
 271
 272     CHECK(msg != nullptr);
 273
 274     CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
 275     CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
 276
 277     CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
 278
 279     dbus_message_unref(msg);
 280 }
 281
 282 TEST(DBusMessage, TestOtbrLeaderData)
 283 {
 284     DBusMessage *                              msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
 285     tuple<std::vector<otbr::DBus::LeaderData>> setVals({{1, 2, 3, 4, 5}});
 286     tuple<std::vector<otbr::DBus::LeaderData>> getVals;
 287
 288     CHECK(msg != nullptr);
 289
 290     CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
 291     CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
 292
 293     CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
 294
 295     dbus_message_unref(msg);
 296 }
 297
 298 TEST(DBusMessage, TestOtbrActiveScanResults)
 299 {
 300     DBusMessage *                                    msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
 301     tuple<std::vector<otbr::DBus::ActiveScanResult>> setVals({{1, "a", 2, {3}, 4, 5, 6, 7, 8, 9, true, true}});
 302     tuple<std::vector<otbr::DBus::ActiveScanResult>> getVals;
 303
 304     CHECK(msg != nullptr);
 305
 306     CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
 307     CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
 308
 309     CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
 310
 311     dbus_message_unref(msg);
 312 }
 313
 314 TEST(DBusMessage, TestOtbrExternalRoute)
 315 {
 316     DBusMessage *                                 msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
 317     tuple<std::vector<otbr::DBus::ExternalRoute>> setVals(
 318         {{otbr::DBus::Ip6Prefix({{0xfa, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}, 64}), uint16_t(0xfc00), 1, true,
 319           true}});
 320     tuple<std::vector<otbr::DBus::ExternalRoute>> getVals;
 321
 322     CHECK(msg != nullptr);
 323
 324     CHECK(TupleToDBusMessage(*msg, setVals) == OTBR_ERROR_NONE);
 325     CHECK(DBusMessageToTuple(*msg, getVals) == OTBR_ERROR_NONE);
 326
 327     CHECK(std::get<0>(setVals)[0] == std::get<0>(getVals)[0]);
 328
 329     dbus_message_unref(msg);
 330 }