14fe85a30SPatrick Williams #include <iostream> 24fe85a30SPatrick Williams #include <cassert> 34fe85a30SPatrick Williams #include <sdbusplus/message.hpp> 44fe85a30SPatrick Williams #include <sdbusplus/bus.hpp> 5*28dc36d5SEd Tanous #include <unordered_map> 6*28dc36d5SEd Tanous #include <set> 74fe85a30SPatrick Williams 84fe85a30SPatrick Williams // Global to share the dbus type string between client and server. 94fe85a30SPatrick Williams static std::string verifyTypeString; 104fe85a30SPatrick Williams 114fe85a30SPatrick Williams using verifyCallback_t = void (*)(sdbusplus::message::message&); 124fe85a30SPatrick Williams verifyCallback_t verifyCallback = nullptr; 134fe85a30SPatrick Williams 1424fb2968SPatrick Williams static constexpr auto SERVICE = "sdbusplus.test.message.read"; 154fe85a30SPatrick Williams static constexpr auto INTERFACE = SERVICE; 164fe85a30SPatrick Williams static constexpr auto TEST_METHOD = "test"; 174fe85a30SPatrick Williams static constexpr auto QUIT_METHOD = "quit"; 184fe85a30SPatrick Williams 194fe85a30SPatrick Williams // Open up the sdbus and claim SERVICE name. 204fe85a30SPatrick Williams auto serverInit() 214fe85a30SPatrick Williams { 224fe85a30SPatrick Williams auto b = sdbusplus::bus::new_default(); 234fe85a30SPatrick Williams b.request_name(SERVICE); 244fe85a30SPatrick Williams 254fe85a30SPatrick Williams return std::move(b); 264fe85a30SPatrick Williams } 274fe85a30SPatrick Williams 284fe85a30SPatrick Williams // Thread to run the dbus server. 294fe85a30SPatrick Williams void* server(void* b) 304fe85a30SPatrick Williams { 314fe85a30SPatrick Williams auto bus = sdbusplus::bus::bus(reinterpret_cast<sdbusplus::bus::busp_t>(b)); 324fe85a30SPatrick Williams 334fe85a30SPatrick Williams while (1) 344fe85a30SPatrick Williams { 354fe85a30SPatrick Williams // Wait for messages. 364fe85a30SPatrick Williams auto m = bus.process(); 374fe85a30SPatrick Williams 384fe85a30SPatrick Williams if (!m) 394fe85a30SPatrick Williams { 404fe85a30SPatrick Williams bus.wait(); 414fe85a30SPatrick Williams continue; 424fe85a30SPatrick Williams } 434fe85a30SPatrick Williams 444fe85a30SPatrick Williams if (m.is_method_call(INTERFACE, TEST_METHOD)) 454fe85a30SPatrick Williams { 464fe85a30SPatrick Williams // Verify the message type matches what the test expects. 474fe85a30SPatrick Williams assert(verifyTypeString == m.get_signature()); 484fe85a30SPatrick Williams 494fe85a30SPatrick Williams if (verifyCallback) 504fe85a30SPatrick Williams { 514fe85a30SPatrick Williams 524fe85a30SPatrick Williams verifyCallback(m); 534fe85a30SPatrick Williams verifyCallback = nullptr; 544fe85a30SPatrick Williams } 554fe85a30SPatrick Williams else 564fe85a30SPatrick Williams { 57072da3eaSAndrew Geissler std::cout << "Warning: No verification for " << verifyTypeString 58072da3eaSAndrew Geissler << std::endl; 594fe85a30SPatrick Williams } 604fe85a30SPatrick Williams // Reply to client. 614fe85a30SPatrick Williams sd_bus_reply_method_return(m.release(), nullptr); 624fe85a30SPatrick Williams } 634fe85a30SPatrick Williams else if (m.is_method_call(INTERFACE, QUIT_METHOD)) 644fe85a30SPatrick Williams { 654fe85a30SPatrick Williams // Reply and exit. 664fe85a30SPatrick Williams sd_bus_reply_method_return(m.release(), nullptr); 674fe85a30SPatrick Williams break; 684fe85a30SPatrick Williams } 694fe85a30SPatrick Williams } 70696e3159SPatrick Williams 71696e3159SPatrick Williams return nullptr; 724fe85a30SPatrick Williams } 734fe85a30SPatrick Williams 744fe85a30SPatrick Williams auto newMethodCall__test(sdbusplus::bus::bus& b) 754fe85a30SPatrick Williams { 764fe85a30SPatrick Williams // Allocate a method-call message for INTERFACE,TEST_METHOD. 774fe85a30SPatrick Williams return b.new_method_call(SERVICE, "/", INTERFACE, TEST_METHOD); 784fe85a30SPatrick Williams } 794fe85a30SPatrick Williams 804fe85a30SPatrick Williams void runTests() 814fe85a30SPatrick Williams { 824fe85a30SPatrick Williams using namespace std::literals; 834fe85a30SPatrick Williams 844fe85a30SPatrick Williams auto b = sdbusplus::bus::new_default(); 854fe85a30SPatrick Williams 864fe85a30SPatrick Williams // Test r-value int. 874fe85a30SPatrick Williams { 884fe85a30SPatrick Williams auto m = newMethodCall__test(b); 894fe85a30SPatrick Williams m.append(1); 904fe85a30SPatrick Williams verifyTypeString = "i"; 914fe85a30SPatrick Williams 924fe85a30SPatrick Williams struct verify 934fe85a30SPatrick Williams { 944fe85a30SPatrick Williams static void op(sdbusplus::message::message& m) 954fe85a30SPatrick Williams { 964fe85a30SPatrick Williams int32_t i = 0; 974fe85a30SPatrick Williams m.read(i); 984fe85a30SPatrick Williams assert(i == 1); 994fe85a30SPatrick Williams } 1004fe85a30SPatrick Williams }; 1014fe85a30SPatrick Williams verifyCallback = &verify::op; 1024fe85a30SPatrick Williams 1034fe85a30SPatrick Williams b.call_noreply(m); 1044fe85a30SPatrick Williams } 1054fe85a30SPatrick Williams // Test l-value int. 1064fe85a30SPatrick Williams { 1074fe85a30SPatrick Williams auto m = newMethodCall__test(b); 1084fe85a30SPatrick Williams int a = 1; 1094fe85a30SPatrick Williams m.append(a, a); 1104fe85a30SPatrick Williams verifyTypeString = "ii"; 1114fe85a30SPatrick Williams 1124fe85a30SPatrick Williams struct verify 1134fe85a30SPatrick Williams { 1144fe85a30SPatrick Williams static void op(sdbusplus::message::message& m) 1154fe85a30SPatrick Williams { 1164fe85a30SPatrick Williams int32_t a = 0, b = 0; 1174fe85a30SPatrick Williams m.read(a, b); 1184fe85a30SPatrick Williams assert(a == 1); 1194fe85a30SPatrick Williams assert(b == 1); 1204fe85a30SPatrick Williams } 1214fe85a30SPatrick Williams }; 1224fe85a30SPatrick Williams verifyCallback = &verify::op; 1234fe85a30SPatrick Williams 1244fe85a30SPatrick Williams b.call_noreply(m); 1254fe85a30SPatrick Williams } 1264fe85a30SPatrick Williams 1274fe85a30SPatrick Williams // Test multiple ints. 1284fe85a30SPatrick Williams { 1294fe85a30SPatrick Williams auto m = newMethodCall__test(b); 1304fe85a30SPatrick Williams m.append(1, 2, 3, 4, 5); 1314fe85a30SPatrick Williams verifyTypeString = "iiiii"; 1324fe85a30SPatrick Williams 1334fe85a30SPatrick Williams struct verify 1344fe85a30SPatrick Williams { 1354fe85a30SPatrick Williams static void op(sdbusplus::message::message& m) 1364fe85a30SPatrick Williams { 1374fe85a30SPatrick Williams int32_t a = 0, b = 0, c = 0, d = 0, e = 0; 1384fe85a30SPatrick Williams m.read(a, b, c, d, e); 1394fe85a30SPatrick Williams assert(a == 1); 1404fe85a30SPatrick Williams assert(b == 2); 1414fe85a30SPatrick Williams assert(c == 3); 1424fe85a30SPatrick Williams assert(d == 4); 1434fe85a30SPatrick Williams assert(e == 5); 1444fe85a30SPatrick Williams } 1454fe85a30SPatrick Williams }; 1464fe85a30SPatrick Williams verifyCallback = &verify::op; 1474fe85a30SPatrick Williams 1484fe85a30SPatrick Williams b.call_noreply(m); 1494fe85a30SPatrick Williams } 1504fe85a30SPatrick Williams 1519e3b51e3SPatrick Williams // Test double and bool. 1529e3b51e3SPatrick Williams { 1539e3b51e3SPatrick Williams auto m = newMethodCall__test(b); 1549e3b51e3SPatrick Williams bool t = true; 155b760a99cSPatrick Williams bool f = false; 156b760a99cSPatrick Williams bool f2 = false; 157b760a99cSPatrick Williams m.append(t, true, f, std::move(f2), false, 1.1); 158b760a99cSPatrick Williams verifyTypeString = "bbbbbd"; 1599e3b51e3SPatrick Williams 1609e3b51e3SPatrick Williams struct verify 1619e3b51e3SPatrick Williams { 1629e3b51e3SPatrick Williams static void op(sdbusplus::message::message& m) 1639e3b51e3SPatrick Williams { 164b760a99cSPatrick Williams bool t1, t2, f1, f2, f3; 1659e3b51e3SPatrick Williams double d; 166b760a99cSPatrick Williams m.read(t1, t2, f1, f2, f3, d); 1679e3b51e3SPatrick Williams assert(t1); 1689e3b51e3SPatrick Williams assert(t2); 1699e3b51e3SPatrick Williams assert(!f1); 170b760a99cSPatrick Williams assert(!f2); 171b760a99cSPatrick Williams assert(!f3); 1729e3b51e3SPatrick Williams assert(d == 1.1); 1739e3b51e3SPatrick Williams } 1749e3b51e3SPatrick Williams }; 1759e3b51e3SPatrick Williams verifyCallback = &verify::op; 1769e3b51e3SPatrick Williams 1779e3b51e3SPatrick Williams b.call_noreply(m); 1789e3b51e3SPatrick Williams } 1799e3b51e3SPatrick Williams 1804fe85a30SPatrick Williams // Test r-value string. 1814fe85a30SPatrick Williams { 1824fe85a30SPatrick Williams auto m = newMethodCall__test(b); 1834fe85a30SPatrick Williams m.append("asdf"s); 1844fe85a30SPatrick Williams verifyTypeString = "s"; 1854fe85a30SPatrick Williams 1864fe85a30SPatrick Williams struct verify 1874fe85a30SPatrick Williams { 1884fe85a30SPatrick Williams static void op(sdbusplus::message::message& m) 1894fe85a30SPatrick Williams { 1904fe85a30SPatrick Williams const char* s = nullptr; 1914fe85a30SPatrick Williams m.read(s); 1924fe85a30SPatrick Williams assert(0 == strcmp("asdf", s)); 1934fe85a30SPatrick Williams } 1944fe85a30SPatrick Williams }; 1954fe85a30SPatrick Williams verifyCallback = &verify::op; 1964fe85a30SPatrick Williams 1974fe85a30SPatrick Williams b.call_noreply(m); 1984fe85a30SPatrick Williams } 1994fe85a30SPatrick Williams 2004fe85a30SPatrick Williams // Test multiple strings, various forms. 2014fe85a30SPatrick Williams { 2024fe85a30SPatrick Williams auto m = newMethodCall__test(b); 2034fe85a30SPatrick Williams auto str = "jkl;"s; 2044fe85a30SPatrick Williams auto str2 = "JKL:"s; 205072da3eaSAndrew Geissler m.append(1, "asdf", "ASDF"s, str, std::move(str2), 5); 2064fe85a30SPatrick Williams verifyTypeString = "issssi"; 2074fe85a30SPatrick Williams 2084fe85a30SPatrick Williams struct verify 2094fe85a30SPatrick Williams { 2104fe85a30SPatrick Williams static void op(sdbusplus::message::message& m) 2114fe85a30SPatrick Williams { 2124fe85a30SPatrick Williams int32_t a = 0, b = 0; 2134fe85a30SPatrick Williams std::string s0, s1, s2, s3; 2144fe85a30SPatrick Williams m.read(a, s0, s1, s2, s3, b); 2154fe85a30SPatrick Williams assert(a == 1); 2164fe85a30SPatrick Williams assert(b == 5); 2174fe85a30SPatrick Williams assert(s0 == "asdf"s); 2184fe85a30SPatrick Williams assert(s1 == "ASDF"s); 2194fe85a30SPatrick Williams assert(s2 == "jkl;"s); 2204fe85a30SPatrick Williams assert(s3 == "JKL:"); 2214fe85a30SPatrick Williams } 2224fe85a30SPatrick Williams }; 2234fe85a30SPatrick Williams verifyCallback = &verify::op; 2244fe85a30SPatrick Williams 2254fe85a30SPatrick Williams b.call_noreply(m); 2264fe85a30SPatrick Williams } 2274fe85a30SPatrick Williams 228572a8ea6SPatrick Williams // Test object_path and signature. 229572a8ea6SPatrick Williams { 230572a8ea6SPatrick Williams auto m = newMethodCall__test(b); 231572a8ea6SPatrick Williams auto o = sdbusplus::message::object_path("/asdf"); 232572a8ea6SPatrick Williams auto s = sdbusplus::message::signature("iii"); 233572a8ea6SPatrick Williams m.append(1, o, s, 4); 234572a8ea6SPatrick Williams verifyTypeString = "iogi"; 235572a8ea6SPatrick Williams 236572a8ea6SPatrick Williams struct verify 237572a8ea6SPatrick Williams { 238572a8ea6SPatrick Williams static void op(sdbusplus::message::message& m) 239572a8ea6SPatrick Williams { 240572a8ea6SPatrick Williams int32_t a = 0, b = 0; 241572a8ea6SPatrick Williams sdbusplus::message::object_path o; 242572a8ea6SPatrick Williams sdbusplus::message::signature s; 243572a8ea6SPatrick Williams m.read(a, o, s, b); 244572a8ea6SPatrick Williams assert(a == 1); 245572a8ea6SPatrick Williams assert(b == 4); 246572a8ea6SPatrick Williams assert(std::string(o) == "/asdf"s); 247572a8ea6SPatrick Williams assert(std::string(s) == "iii"s); 248572a8ea6SPatrick Williams } 249572a8ea6SPatrick Williams }; 250572a8ea6SPatrick Williams verifyCallback = &verify::op; 251572a8ea6SPatrick Williams 252572a8ea6SPatrick Williams b.call_noreply(m); 253572a8ea6SPatrick Williams } 254572a8ea6SPatrick Williams 255930460c0SPatrick Williams // Test vector. 256930460c0SPatrick Williams { 257930460c0SPatrick Williams auto m = newMethodCall__test(b); 258930460c0SPatrick Williams std::vector<std::string> s{"1", "2", "3"}; 259930460c0SPatrick Williams m.append(1, s, 2); 260930460c0SPatrick Williams verifyTypeString = "iasi"; 261930460c0SPatrick Williams 262930460c0SPatrick Williams struct verify 263930460c0SPatrick Williams { 264930460c0SPatrick Williams static void op(sdbusplus::message::message& m) 265930460c0SPatrick Williams { 266930460c0SPatrick Williams int32_t a = 0; 267930460c0SPatrick Williams std::vector<std::string> s; 268930460c0SPatrick Williams m.read(a, s); 269930460c0SPatrick Williams assert(a == 1); 270930460c0SPatrick Williams assert(s[0] == "1"); 271930460c0SPatrick Williams assert(s[1] == "2"); 272930460c0SPatrick Williams assert(s[2] == "3"); 273930460c0SPatrick Williams decltype(s) s2 = {"1", "2", "3"}; 274930460c0SPatrick Williams assert(s == s2); 275930460c0SPatrick Williams } 276930460c0SPatrick Williams }; 277930460c0SPatrick Williams verifyCallback = &verify::op; 278930460c0SPatrick Williams 279930460c0SPatrick Williams b.call_noreply(m); 280930460c0SPatrick Williams } 281930460c0SPatrick Williams 282bbe0e436SPatrick Williams // Test map. 283bbe0e436SPatrick Williams { 284bbe0e436SPatrick Williams auto m = newMethodCall__test(b); 285bbe0e436SPatrick Williams std::map<std::string, int> s = {{"asdf", 3}, {"jkl;", 4}}; 286bbe0e436SPatrick Williams m.append(1, s, 2); 287bbe0e436SPatrick Williams verifyTypeString = "ia{si}i"; 288bbe0e436SPatrick Williams 289bbe0e436SPatrick Williams struct verify 290bbe0e436SPatrick Williams { 291bbe0e436SPatrick Williams static void op(sdbusplus::message::message& m) 292bbe0e436SPatrick Williams { 293bbe0e436SPatrick Williams int32_t a = 0, b = 0; 294bbe0e436SPatrick Williams std::map<std::string, int> s{}; 295bbe0e436SPatrick Williams 296bbe0e436SPatrick Williams m.read(a, s, b); 297bbe0e436SPatrick Williams assert(a == 1); 298bbe0e436SPatrick Williams assert(s.size() == 2); 299bbe0e436SPatrick Williams assert(s["asdf"] == 3); 300bbe0e436SPatrick Williams assert(s["jkl;"] == 4); 301bbe0e436SPatrick Williams assert(b == 2); 302bbe0e436SPatrick Williams } 303bbe0e436SPatrick Williams }; 304bbe0e436SPatrick Williams verifyCallback = &verify::op; 305bbe0e436SPatrick Williams 306bbe0e436SPatrick Williams b.call_noreply(m); 307bbe0e436SPatrick Williams } 308bbe0e436SPatrick Williams 309*28dc36d5SEd Tanous // Test unordered_map. 310*28dc36d5SEd Tanous { 311*28dc36d5SEd Tanous auto m = newMethodCall__test(b); 312*28dc36d5SEd Tanous std::unordered_map<std::string, int> s = {{"asdf", 3}, {"jkl;", 4}}; 313*28dc36d5SEd Tanous m.append(1, s, 2); 314*28dc36d5SEd Tanous verifyTypeString = "ia{si}i"; 315*28dc36d5SEd Tanous 316*28dc36d5SEd Tanous struct verify 317*28dc36d5SEd Tanous { 318*28dc36d5SEd Tanous static void op(sdbusplus::message::message& m) 319*28dc36d5SEd Tanous { 320*28dc36d5SEd Tanous int32_t a = 0, b = 0; 321*28dc36d5SEd Tanous std::unordered_map<std::string, int> s{}; 322*28dc36d5SEd Tanous 323*28dc36d5SEd Tanous m.read(a, s, b); 324*28dc36d5SEd Tanous assert(a == 1); 325*28dc36d5SEd Tanous assert(s.size() == 2); 326*28dc36d5SEd Tanous assert(s["asdf"] == 3); 327*28dc36d5SEd Tanous assert(s["jkl;"] == 4); 328*28dc36d5SEd Tanous assert(b == 2); 329*28dc36d5SEd Tanous } 330*28dc36d5SEd Tanous }; 331*28dc36d5SEd Tanous verifyCallback = &verify::op; 332*28dc36d5SEd Tanous 333*28dc36d5SEd Tanous b.call_noreply(m); 334*28dc36d5SEd Tanous } 335*28dc36d5SEd Tanous 336*28dc36d5SEd Tanous // Test set. 337*28dc36d5SEd Tanous { 338*28dc36d5SEd Tanous auto m = newMethodCall__test(b); 339*28dc36d5SEd Tanous std::set<std::string> s = {{"asdf"}, {"jkl;"}}; 340*28dc36d5SEd Tanous m.append(1, s, 2); 341*28dc36d5SEd Tanous verifyTypeString = "iasi"; 342*28dc36d5SEd Tanous 343*28dc36d5SEd Tanous struct verify 344*28dc36d5SEd Tanous { 345*28dc36d5SEd Tanous static void op(sdbusplus::message::message& m) 346*28dc36d5SEd Tanous { 347*28dc36d5SEd Tanous int32_t a = 0, b = 0; 348*28dc36d5SEd Tanous std::set<std::string> s{}; 349*28dc36d5SEd Tanous 350*28dc36d5SEd Tanous m.read(a, s, b); 351*28dc36d5SEd Tanous assert(a == 1); 352*28dc36d5SEd Tanous assert(s.size() == 2); 353*28dc36d5SEd Tanous assert(s.find("asdf") != s.end()); 354*28dc36d5SEd Tanous assert(s.find("jkl;") != s.end()); 355*28dc36d5SEd Tanous assert(b == 2); 356*28dc36d5SEd Tanous } 357*28dc36d5SEd Tanous }; 358*28dc36d5SEd Tanous verifyCallback = &verify::op; 359*28dc36d5SEd Tanous 360*28dc36d5SEd Tanous b.call_noreply(m); 361*28dc36d5SEd Tanous } 362*28dc36d5SEd Tanous 363aa2f48afSPatrick Williams // Test tuple. 364aa2f48afSPatrick Williams { 365aa2f48afSPatrick Williams auto m = newMethodCall__test(b); 366aa2f48afSPatrick Williams std::tuple<int, double, std::string> a{3, 4.1, "asdf"}; 367aa2f48afSPatrick Williams m.append(1, a, 2); 368aa2f48afSPatrick Williams verifyTypeString = "i(ids)i"; 369bbe0e436SPatrick Williams 370aa2f48afSPatrick Williams struct verify 371aa2f48afSPatrick Williams { 372aa2f48afSPatrick Williams static void op(sdbusplus::message::message& m) 373aa2f48afSPatrick Williams { 374aa2f48afSPatrick Williams int32_t a = 0, b = 0; 375aa2f48afSPatrick Williams std::tuple<int, double, std::string> c{}; 376aa2f48afSPatrick Williams 377aa2f48afSPatrick Williams m.read(a, c, b); 378aa2f48afSPatrick Williams assert(a == 1); 379aa2f48afSPatrick Williams assert(b == 2); 380aa2f48afSPatrick Williams assert(c == std::make_tuple(3, 4.1, "asdf"s)); 381aa2f48afSPatrick Williams } 382aa2f48afSPatrick Williams }; 383aa2f48afSPatrick Williams verifyCallback = &verify::op; 384aa2f48afSPatrick Williams 385aa2f48afSPatrick Williams b.call_noreply(m); 386aa2f48afSPatrick Williams } 387bbe0e436SPatrick Williams 38875596786SPatrick Williams // Test variant. 38975596786SPatrick Williams { 39075596786SPatrick Williams auto m = newMethodCall__test(b); 39175596786SPatrick Williams sdbusplus::message::variant<int, double> a1{3.1}, a2{4}; 39275596786SPatrick Williams m.append(1, a1, a2, 2); 39375596786SPatrick Williams verifyTypeString = "ivvi"; 39475596786SPatrick Williams 39575596786SPatrick Williams struct verify 39675596786SPatrick Williams { 39775596786SPatrick Williams static void op(sdbusplus::message::message& m) 39875596786SPatrick Williams { 39975596786SPatrick Williams int32_t a, b; 40075596786SPatrick Williams sdbusplus::message::variant<int, double> a1{}, a2{}; 40175596786SPatrick Williams 40275596786SPatrick Williams m.read(a, a1, a2, b); 40375596786SPatrick Williams assert(a == 1); 40475596786SPatrick Williams assert(a1 == 3.1); 40575596786SPatrick Williams assert(a2 == 4); 40675596786SPatrick Williams assert(b == 2); 40775596786SPatrick Williams } 40875596786SPatrick Williams }; 40975596786SPatrick Williams verifyCallback = &verify::op; 41075596786SPatrick Williams 41175596786SPatrick Williams b.call_noreply(m); 41275596786SPatrick Williams } 41375596786SPatrick Williams 414f101ee28SPatrick Williams // Test variant with missing/wrong type. 415f101ee28SPatrick Williams { 416f101ee28SPatrick Williams auto m = newMethodCall__test(b); 417f101ee28SPatrick Williams sdbusplus::message::variant<uint64_t, double> a1{3.1}, a2{uint64_t(4)}; 418f101ee28SPatrick Williams m.append(1, a1, a2, 2); 419f101ee28SPatrick Williams verifyTypeString = "ivvi"; 420f101ee28SPatrick Williams 421f101ee28SPatrick Williams struct verify 422f101ee28SPatrick Williams { 423f101ee28SPatrick Williams static void op(sdbusplus::message::message& m) 424f101ee28SPatrick Williams { 425f101ee28SPatrick Williams int32_t a, b; 426f101ee28SPatrick Williams sdbusplus::message::variant<uint8_t, double> a1{}, a2{}; 427f101ee28SPatrick Williams 428f101ee28SPatrick Williams m.read(a, a1, a2, b); 429f101ee28SPatrick Williams assert(a == 1); 430f101ee28SPatrick Williams assert(a1 == 3.1); 431f101ee28SPatrick Williams assert(a2 == uint8_t()); 432f101ee28SPatrick Williams assert(b == 2); 433f101ee28SPatrick Williams } 434f101ee28SPatrick Williams }; 435f101ee28SPatrick Williams verifyCallback = &verify::op; 436f101ee28SPatrick Williams 437f101ee28SPatrick Williams b.call_noreply(m); 438f101ee28SPatrick Williams } 439f101ee28SPatrick Williams 44075596786SPatrick Williams // Test map-variant. 44175596786SPatrick Williams { 44275596786SPatrick Williams auto m = newMethodCall__test(b); 443072da3eaSAndrew Geissler std::map<std::string, sdbusplus::message::variant<int, double>> a1 = { 444072da3eaSAndrew Geissler {"asdf", 3}, {"jkl;", 4.1}}; 44575596786SPatrick Williams m.append(1, a1, 2); 44675596786SPatrick Williams verifyTypeString = "ia{sv}i"; 44775596786SPatrick Williams 44875596786SPatrick Williams struct verify 44975596786SPatrick Williams { 45075596786SPatrick Williams static void op(sdbusplus::message::message& m) 45175596786SPatrick Williams { 45275596786SPatrick Williams int32_t a = 0, b = 0; 453072da3eaSAndrew Geissler std::map<std::string, sdbusplus::message::variant<int, double>> 454072da3eaSAndrew Geissler a1{}; 45575596786SPatrick Williams 45675596786SPatrick Williams m.read(a, a1, b); 45775596786SPatrick Williams assert(a == 1); 45875596786SPatrick Williams assert(a1["asdf"] == 3); 45975596786SPatrick Williams assert(a1["jkl;"] == 4.1); 46075596786SPatrick Williams assert(b == 2); 46175596786SPatrick Williams } 46275596786SPatrick Williams }; 46375596786SPatrick Williams verifyCallback = &verify::op; 46475596786SPatrick Williams 46575596786SPatrick Williams b.call_noreply(m); 46675596786SPatrick Williams } 46775596786SPatrick Williams 4684fe85a30SPatrick Williams // Shutdown server. 4694fe85a30SPatrick Williams { 4704fe85a30SPatrick Williams auto m = b.new_method_call(SERVICE, "/", INTERFACE, QUIT_METHOD); 4714fe85a30SPatrick Williams b.call_noreply(m); 4724fe85a30SPatrick Williams } 4734fe85a30SPatrick Williams } 4744fe85a30SPatrick Williams 4754fe85a30SPatrick Williams int main() 4764fe85a30SPatrick Williams { 4774fe85a30SPatrick Williams 4784fe85a30SPatrick Williams // Initialize and start server thread. 4794fe85a30SPatrick Williams pthread_t t; 4804fe85a30SPatrick Williams { 4814fe85a30SPatrick Williams auto b = serverInit(); 4824fe85a30SPatrick Williams pthread_create(&t, NULL, server, b.release()); 4834fe85a30SPatrick Williams } 4844fe85a30SPatrick Williams 4854fe85a30SPatrick Williams runTests(); 4864fe85a30SPatrick Williams 4874fe85a30SPatrick Williams // Wait for server thread to exit. 4884fe85a30SPatrick Williams pthread_join(t, NULL); 4894fe85a30SPatrick Williams 4904fe85a30SPatrick Williams return 0; 4914fe85a30SPatrick Williams } 492