/******************************************************************************** * Copyright (c) 2025-2026 ZF Friedrichshafen AG * * This program and the accompanying materials are made available under the * terms of the Apache License Version 2.0 which is available at * https://www.apache.org/licenses/LICENSE-2.0 * * SPDX-License-Identifier: Apache-2.0 * * Contributors: * Erik Verhoeven - initial API and implementation ********************************************************************************/ #include "../../include/gtest_custom.h" #include "../../../sdv_services/ipc_com/com_ctrl.h" #include "../../../sdv_services/ipc_com/com_channel.h" #include "../../../sdv_services/ipc_com/marshall_object.h" #include #include #include #include "generated/test_ifc.h" EHello& operator++(EHello& reHello, int) { switch (reHello) { case EHello::hi: reHello = EHello::huhu; break; case EHello::huhu: reHello = EHello::hello; break; case EHello::hello: reHello = EHello::hallo; break; case EHello::hallo: reHello = EHello::servus; break; case EHello::servus: reHello = EHello::gruessgott; break; case EHello::gruessgott: reHello = EHello::hi; break; default: break; } return reHello; } EHello& operator--(EHello& reHello, int) { switch (reHello) { case EHello::hi: reHello = EHello::gruessgott; break; case EHello::huhu: reHello = EHello::hi; break; case EHello::hello: reHello = EHello::huhu; break; case EHello::hallo: reHello = EHello::hello; break; case EHello::servus: reHello = EHello::hallo; break; case EHello::gruessgott: reHello = EHello::servus; break; default: break; } return reHello; } /** * - Instantiate service * - Assign server endpoint * - Assign server endpoint + assign client endpoint * - Create channel endpoint * - Create channel endpoint + connect channel endpoint * - Create proxy/stub connection * - Reconnect * - Multiple connections * - Get other interface * - Multiple access interface * - Random multiple access interface * - Random multiple access interface with reconnect */ class CInterfaceTest : public ISayHello, public IRequestHello, public IRegisterHelloCallback, public IMegaTest, public sdv::IInterfaceAccess { public: BEGIN_SDV_INTERFACE_MAP() SDV_INTERFACE_ENTRY(ISayHello) SDV_INTERFACE_ENTRY(IRequestHello) SDV_INTERFACE_ENTRY(IRegisterHelloCallback) SDV_INTERFACE_ENTRY(IMegaTest) SDV_INTERFACE_ENTRY(sdv::IInterfaceAccess) END_SDV_INTERFACE_MAP() /** * @brief Say hello! * @return The greeting text. */ virtual sdv::string Hello() override { return "Hello"; } /** * @brief Request the hello interface. * @return pHello The hello interface. */ virtual ISayHello* Request() { return this; } /** * @brief Register the callback with the hello interface. * @param[in] pHello The hello interface. */ virtual void Register(/*in*/ ISayHello* pHello) { m_pHello = pHello; } /** * @brief Update the mega struct. This will test marshalling and unmarshalling of the mega struct. Overload of * IMegaTest::ProcessMegaStruct. * @param[in] rsStruct Reference to the mega struct. */ virtual void ProcessMegaStruct(/*inout*/ SMegaStruct& rsStruct) override { rsStruct.bVal = !rsStruct.bVal; rsStruct.sVal--; rsStruct.usVal++; rsStruct.lVal--; rsStruct.ulVal++; rsStruct.llVal--; rsStruct.ullVal++; rsStruct.i8Val--; rsStruct.ui8Val++; rsStruct.i16Val--; rsStruct.ui16Val++; rsStruct.i32Val--; rsStruct.ui32Val++; rsStruct.i64Val--; rsStruct.ui64Val++; rsStruct.cVal++; rsStruct.c16Val++; rsStruct.c32Val++; rsStruct.wcVal++; rsStruct.fVal -= 1000.000f; rsStruct.dVal += 1000.000; rsStruct.ldVal -= 1000.000; rsStruct.nVal++; rsStruct.eHelloVal = rsStruct.eHelloVal++; if (rsStruct.idVal == sdv::GetInterfaceId()) rsStruct.idVal = sdv::GetInterfaceId(); else rsStruct.idVal = 0; rsStruct.ssVal += rsStruct.ssVal.empty() ? 'x' : rsStruct.ssVal.back() + 1; rsStruct.ss8Val += rsStruct.ss8Val.empty() ? 'x' : rsStruct.ss8Val.back() + 1; rsStruct.ss16Val += rsStruct.ss16Val.empty() ? u'x' : rsStruct.ss16Val.back() + 1; rsStruct.ss32Val += rsStruct.ss32Val.empty() ? U'x' : rsStruct.ss32Val.back() + 1; rsStruct.wssVal += rsStruct.wssVal.empty() ? L'x' : rsStruct.wssVal.back() + 1; rsStruct.ssFixVal += rsStruct.ssFixVal.empty() ? 'x' : rsStruct.ssFixVal.back() + 1; rsStruct.ss8FixVal += rsStruct.ss8FixVal.empty() ? 'x' : rsStruct.ss8FixVal.back() + 1; rsStruct.ss16FixVal += rsStruct.ss16FixVal.empty() ? u'x' : rsStruct.ss16FixVal.back() + 1; rsStruct.ss32FixVal += rsStruct.ss32FixVal.empty() ? U'x' : rsStruct.ss32FixVal.back() + 1; rsStruct.wssFixVal += rsStruct.wssFixVal.empty() ? L'x' : rsStruct.wssFixVal.back() + 1; rsStruct.ptr8Val.resize(rsStruct.ptr8Val.size() * 2); for (size_t nIndex = 0; nIndex < rsStruct.ptr8Val.size() / 2; nIndex++) rsStruct.ptr8Val[nIndex + rsStruct.ptr8Val.size() / 2] = rsStruct.ptr8Val[nIndex]; rsStruct.ptrssVal.resize(rsStruct.ptrssVal.size() * 2); for (size_t nIndex = 0; nIndex < rsStruct.ptrssVal.size() / 2; nIndex++) rsStruct.ptrssVal[nIndex + rsStruct.ptrssVal.size() / 2] = rsStruct.ptrssVal[nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.ptr8FixVal.size(); nIndex++) rsStruct.ptr8FixVal[nIndex] = static_cast(rsStruct.ptr8FixVal[nIndex] << 1); for (size_t nIndex = 0; nIndex < rsStruct.ptrssFixVal.size(); nIndex++) rsStruct.ptrssFixVal[nIndex] = rsStruct.ptrssFixVal[nIndex] + rsStruct.ptrssFixVal[nIndex]; rsStruct.seq8Val.resize(rsStruct.seq8Val.size() * 2); for (size_t nIndex = 0; nIndex < rsStruct.seq8Val.size() / 2; nIndex++) rsStruct.seq8Val[nIndex + rsStruct.seq8Val.size() / 2] = rsStruct.seq8Val[nIndex]; rsStruct.seqssVal.resize(rsStruct.seqssVal.size() * 2); for (size_t nIndex = 0; nIndex < rsStruct.seqssVal.size() / 2; nIndex++) rsStruct.seqssVal[nIndex + rsStruct.seqssVal.size() / 2] = rsStruct.seqssVal[nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.seq8FixVal.size(); nIndex++) rsStruct.seq8FixVal[nIndex] = static_cast(rsStruct.seq8FixVal[nIndex] << 1); for (size_t nIndex = 0; nIndex < rsStruct.seqssFixVal.size(); nIndex++) rsStruct.seqssFixVal[nIndex] = rsStruct.seqssFixVal[nIndex] + rsStruct.seqssFixVal[nIndex]; if (rsStruct.ifcVal.get() && rsStruct.ifcVal.id() == sdv::GetInterfaceId()) { m_summer.set(rsStruct.ifcVal.get()); rsStruct.ifcVal = static_cast(&m_summer); } else rsStruct.ifcVal = nullptr; if (rsStruct.pMultiplyValue) { m_multiplier.set(rsStruct.pMultiplyValue); rsStruct.pMultiplyValue = static_cast(&m_multiplier); } else rsStruct.pMultiplyValue = nullptr; rsStruct.sSubVal.i += 1; rsStruct.sIndVal.i += 10; //rsStruct.sUnnamedVal.i += 20; // 12.04.2024 EVE Unnamed structures are not supported by IDL compiler. // Unnamed unions (inline definition) are not supported yet: PBI #398209 //union switch(int32) { case 0: int32 i; default: int32 j; } uUnnamedVal; // Anonymous structs and unions (unnamed and no declaration) are not supported yet: PBI #397894 //struct { int32 iAnonymous1; int32 iAnonymous2; }; //union switch(int32) { case 0: int32 iAnonymous1; default: int32 iAnonymous2; }; rsStruct.rgbVal[0] = !rsStruct.rgbVal[0]; rsStruct.rgbVal[1] = !rsStruct.rgbVal[1]; rsStruct.rgsVal[0]--; rsStruct.rgsVal[1]++; rsStruct.rgusVal[0]++; rsStruct.rgusVal[1] += 2; rsStruct.rglVal[0]--; rsStruct.rglVal[1]++; rsStruct.rgulVal[0]++; rsStruct.rgulVal[1] += 2; rsStruct.rgllVal[0]--; rsStruct.rgllVal[1]++; rsStruct.rgullVal[0]++; rsStruct.rgullVal[1] += 2; rsStruct.rgi8Val[0]--; rsStruct.rgi8Val[1]++; rsStruct.rgui8Val[0]++; rsStruct.rgui8Val[1] += 2; rsStruct.rgi16Val[0]--; rsStruct.rgi16Val[1]++; rsStruct.rgui16Val[0]++; rsStruct.rgui16Val[1] += 2; rsStruct.rgi32Val[0]--; rsStruct.rgi32Val[1]++; rsStruct.rgui32Val[0]++; rsStruct.rgui32Val[1] += 2; rsStruct.rgi64Val[0]--; rsStruct.rgi64Val[1]++; rsStruct.rgui64Val[0]++; rsStruct.rgui64Val[1] += 2; rsStruct.rgcVal[0]++; rsStruct.rgcVal[1] += 2; rsStruct.rgc16Val[0]++; rsStruct.rgc16Val[1] += 2; rsStruct.rgc32Val[0]++; rsStruct.rgc32Val[1] += 2; rsStruct.rgwcVal[0]++; rsStruct.rgwcVal[1] += 2; rsStruct.rgfVal[0] -= 1000.000f; rsStruct.rgfVal[1] += 2000.000f; rsStruct.rgdVal[0] += 1000.000; rsStruct.rgdVal[1] -= 2000.000; rsStruct.rgldVal[0] -= 1000.000; rsStruct.rgldVal[1] += 2000.000; rsStruct.rgnVal[0]++; rsStruct.rgnVal[1] += 2; rsStruct.rgeHelloVal[0] = rsStruct.rgeHelloVal[0]++; rsStruct.rgeHelloVal[1] = rsStruct.rgeHelloVal[1]--; if (rsStruct.rgidVal[0] == sdv::GetInterfaceId()) rsStruct.rgidVal[0] = sdv::GetInterfaceId(); else rsStruct.rgidVal[0] = 0; if (rsStruct.rgidVal[1] == sdv::GetInterfaceId()) rsStruct.rgidVal[1] = sdv::GetInterfaceId(); else rsStruct.rgidVal[1] = 0; rsStruct.rgssVal[0] += rsStruct.rgssVal[0].empty() ? 'x' : rsStruct.rgssVal[0].back() + 1; rsStruct.rgssVal[1] += rsStruct.rgssVal[1].empty() ? 'x' : rsStruct.rgssVal[1].front() + 1; rsStruct.rgss8Val[0] += rsStruct.rgss8Val[0].empty() ? 'x' : rsStruct.rgss8Val[0].back() + 1; rsStruct.rgss8Val[1] += rsStruct.rgss8Val[1].empty() ? 'x' : rsStruct.rgss8Val[1].front() + 1; rsStruct.rgss16Val[0] += rsStruct.rgss16Val[0].empty() ? u'x' : rsStruct.rgss16Val[0].back() + 1; rsStruct.rgss16Val[1] += rsStruct.rgss16Val[1].empty() ? u'x' : rsStruct.rgss16Val[1].front() + 1; rsStruct.rgss32Val[0] += rsStruct.rgss32Val[0].empty() ? U'x' : rsStruct.rgss32Val[0].back() + 1; rsStruct.rgss32Val[1] += rsStruct.rgss32Val[1].empty() ? U'x' : rsStruct.rgss32Val[1].front() + 1; rsStruct.rgwssVal[0] += rsStruct.rgwssVal[0].empty() ? L'x' : rsStruct.rgwssVal[0].back() + 1; rsStruct.rgwssVal[1] += rsStruct.rgwssVal[1].empty() ? L'x' : rsStruct.rgwssVal[1].front() + 1; rsStruct.rgssFixVal[0] += rsStruct.rgssFixVal[0].empty() ? 'x' : rsStruct.rgssFixVal[0].back() + 1; rsStruct.rgssFixVal[1] += rsStruct.rgssFixVal[1].empty() ? 'x' : rsStruct.rgssFixVal[1].front() + 1; rsStruct.rgss8FixVal[0] += rsStruct.rgss8FixVal[0].empty() ? 'x' : rsStruct.rgss8FixVal[0].back() + 1; rsStruct.rgss8FixVal[1] += rsStruct.rgss8FixVal[1].empty() ? 'x' : rsStruct.rgss8FixVal[1].front() + 1; rsStruct.rgss16FixVal[0] += rsStruct.rgss16FixVal[0].empty() ? u'x' : rsStruct.rgss16FixVal[0].back() + 1; rsStruct.rgss16FixVal[1] += rsStruct.rgss16FixVal[1].empty() ? u'x' : rsStruct.rgss16FixVal[1].front() + 1; rsStruct.rgss32FixVal[0] += rsStruct.rgss32FixVal[0].empty() ? U'x' : rsStruct.rgss32FixVal[0].back() + 1; rsStruct.rgss32FixVal[1] += rsStruct.rgss32FixVal[1].empty() ? U'x' : rsStruct.rgss32FixVal[1].front() + 1; rsStruct.rgwssFixVal[0] += rsStruct.rgwssFixVal[0].empty() ? L'x' : rsStruct.rgwssFixVal[0].back() + 1; rsStruct.rgwssFixVal[1] += rsStruct.rgwssFixVal[1].empty() ? L'x' : rsStruct.rgwssFixVal[1].front() + 1; rsStruct.rgptr8Val[0].resize(rsStruct.rgptr8Val[0].size() * 2); rsStruct.rgptr8Val[1].resize(rsStruct.rgptr8Val[1].size() * 3); for (size_t nIndex = 0; nIndex < rsStruct.rgptr8Val[0].size() / 2; nIndex++) rsStruct.rgptr8Val[0][nIndex + rsStruct.rgptr8Val[0].size() / 2] = rsStruct.rgptr8Val[0][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgptr8Val[1].size() / 3; nIndex++) rsStruct.rgptr8Val[1][nIndex + rsStruct.rgptr8Val[1].size() / 3] = rsStruct.rgptr8Val[1][nIndex]; rsStruct.rgptrssVal[0].resize(rsStruct.rgptrssVal[0].size() * 2); rsStruct.rgptrssVal[1].resize(rsStruct.rgptrssVal[1].size() * 3); for (size_t nIndex = 0; nIndex < rsStruct.rgptrssVal[0].size() / 2; nIndex++) rsStruct.rgptrssVal[0][nIndex + rsStruct.rgptrssVal[0].size() / 2] = rsStruct.rgptrssVal[0][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgptrssVal[1].size() / 3; nIndex++) rsStruct.rgptrssVal[1][nIndex + rsStruct.rgptrssVal[1].size() / 3] = rsStruct.rgptrssVal[1][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgptr8FixVal[0].size(); nIndex++) rsStruct.rgptr8FixVal[0][nIndex] = static_cast(rsStruct.rgptr8FixVal[0][nIndex] << 1); for (size_t nIndex = 0; nIndex < rsStruct.rgptr8FixVal[1].size(); nIndex++) rsStruct.rgptr8FixVal[1][nIndex] = static_cast(rsStruct.rgptr8FixVal[1][nIndex] << 1); for (size_t nIndex = 0; nIndex < rsStruct.rgptrssFixVal[0].size(); nIndex++) rsStruct.rgptrssFixVal[0][nIndex] = rsStruct.rgptrssFixVal[0][nIndex] + rsStruct.rgptrssFixVal[0][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgptrssFixVal[1].size(); nIndex++) rsStruct.rgptrssFixVal[1][nIndex] = rsStruct.rgptrssFixVal[1][nIndex] + rsStruct.rgptrssFixVal[1][nIndex]; rsStruct.rgseq8Val[0].resize(rsStruct.rgseq8Val[0].size() * 2); rsStruct.rgseq8Val[1].resize(rsStruct.rgseq8Val[1].size() * 3); for (size_t nIndex = 0; nIndex < rsStruct.rgseq8Val[0].size() / 2; nIndex++) rsStruct.rgseq8Val[0][nIndex + rsStruct.rgseq8Val[0].size() / 2] = rsStruct.rgseq8Val[0][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgseq8Val[1].size() / 3; nIndex++) rsStruct.rgseq8Val[1][nIndex + rsStruct.rgseq8Val[1].size() / 3] = rsStruct.rgseq8Val[1][nIndex]; rsStruct.rgseqssVal[0].resize(rsStruct.rgseqssVal[0].size() * 2); rsStruct.rgseqssVal[1].resize(rsStruct.rgseqssVal[1].size() * 3); for (size_t nIndex = 0; nIndex < rsStruct.rgseqssVal[0].size() / 2; nIndex++) rsStruct.rgseqssVal[0][nIndex + rsStruct.rgseqssVal[0].size() / 2] = rsStruct.rgseqssVal[0][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgseqssVal[1].size() / 3; nIndex++) rsStruct.rgseqssVal[1][nIndex + rsStruct.rgseqssVal[1].size() / 3] = rsStruct.rgseqssVal[1][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgseq8FixVal[0].size(); nIndex++) rsStruct.rgseq8FixVal[0][nIndex] = static_cast(rsStruct.rgseq8FixVal[0][nIndex] << 1); for (size_t nIndex = 0; nIndex < rsStruct.rgseq8FixVal[1].size(); nIndex++) rsStruct.rgseq8FixVal[1][nIndex] = static_cast(rsStruct.rgseq8FixVal[1][nIndex] << 1); for (size_t nIndex = 0; nIndex < rsStruct.rgseqssFixVal[0].size(); nIndex++) rsStruct.rgseqssFixVal[0][nIndex] = rsStruct.rgseqssFixVal[0][nIndex] + rsStruct.rgseqssFixVal[0][nIndex]; for (size_t nIndex = 0; nIndex < rsStruct.rgseqssFixVal[1].size(); nIndex++) rsStruct.rgseqssFixVal[1][nIndex] = rsStruct.rgseqssFixVal[1][nIndex] + rsStruct.rgseqssFixVal[1][nIndex]; // Incompatible serdes generation: BUG #398509 //if (rsStruct.rgifcVal[0].get() && rsStruct.rgifcVal[0].id() == sdv::GetInterfaceId()) //{ // m_summer.set(rsStruct.rgifcVal[0].get()); // rsStruct.rgifcVal[0] = static_cast(&m_summer); //} //else // rsStruct.rgifcVal[0] = nullptr; //if (rsStruct.rgifcVal[1].get() && rsStruct.rgifcVal[1].id() == sdv::GetInterfaceId()) //{ // m_summer.set(rsStruct.rgifcVal[1].get()); // rsStruct.rgifcVal[1] = static_cast(&m_summer); //} //else // rsStruct.rgifcVal[1] = nullptr; //if (rsStruct.rgpMultiplyValue[0]) //{ // m_multiplier.set(rsStruct.rgpMultiplyValue[0]); // rsStruct.rgpMultiplyValue[0] = static_cast(&m_multiplier); //} //else // rsStruct.rgpMultiplyValue[0] = nullptr; //if (rsStruct.rgpMultiplyValue[1]) //{ // m_multiplier.set(rsStruct.rgpMultiplyValue[1]); // rsStruct.rgpMultiplyValue[1] = static_cast(&m_multiplier); //} //else // rsStruct.rgpMultiplyValue[1] = nullptr; rsStruct.rgsSubVal[0].i += 1; rsStruct.rgsSubVal[1].i += 2; // Incompatible serdes generation: BUG #398509 //rsStruct.rgsIndVal[0].i += 10; //rsStruct.rgsIndVal[1].i += 20; // Unnamed struct with array is not yet supported due to incorret serdes code generation: BUG #398246 //rsStruct.rgsUnnamedVal[0].i += 20; //rsStruct.rgsUnnamedVal[1].i += 40; rsStruct.tbVal = !rsStruct.tbVal; rsStruct.tsVal--; rsStruct.tusVal++; rsStruct.tlVal--; rsStruct.tulVal++; rsStruct.tllVal--; rsStruct.tullVal++; rsStruct.ti8Val--; rsStruct.tui8Val++; rsStruct.ti16Val--; rsStruct.tui16Val++; rsStruct.ti32Val--; rsStruct.tui32Val++; rsStruct.ti64Val--; rsStruct.tui64Val++; rsStruct.tcVal++; rsStruct.tc16Val++; rsStruct.tc32Val++; rsStruct.twcVal++; rsStruct.tfVal -= 1000.000f; rsStruct.tdVal += 1000.000; rsStruct.tldVal -= 1000.000; rsStruct.tnVal++; rsStruct.teHelloVal = rsStruct.teHelloVal++; if (rsStruct.tidVal == sdv::GetInterfaceId()) rsStruct.tidVal = sdv::GetInterfaceId(); else rsStruct.tidVal = 0; rsStruct.tssVal += rsStruct.tssVal.empty() ? 'x' : rsStruct.tssVal.back() + 1; rsStruct.tss8Val += rsStruct.tss8Val.empty() ? 'x' : rsStruct.tss8Val.back() + 1; rsStruct.tss16Val += rsStruct.tss16Val.empty() ? u'x' : rsStruct.tss16Val.back() + 1; rsStruct.tss32Val += rsStruct.tss32Val.empty() ? U'x' : rsStruct.tss32Val.back() + 1; rsStruct.twssVal += rsStruct.twssVal.empty() ? L'x' : rsStruct.twssVal.back() + 1; rsStruct.tssFixVal += rsStruct.tssFixVal.empty() ? 'x' : rsStruct.tssFixVal.back() + 1; rsStruct.tss8FixVal += rsStruct.tss8FixVal.empty() ? 'x' : rsStruct.tss8FixVal.back() + 1; rsStruct.tss16FixVal += rsStruct.tss16FixVal.empty() ? u'x' : rsStruct.tss16FixVal.back() + 1; rsStruct.tss32FixVal += rsStruct.tss32FixVal.empty() ? U'x' : rsStruct.tss32FixVal.back() + 1; rsStruct.twssFixVal += rsStruct.twssFixVal.empty() ? L'x' : rsStruct.twssFixVal.back() + 1; // Using typedefs of template based types produced an error: BUG #398266 //rsStruct.tptr8Val.resize(rsStruct.tptr8Val.size() * 2); //for (size_t nIndex = 0; nIndex < rsStruct.tptr8Val.size() / 2; nIndex++) // rsStruct.tptr8Val[nIndex + rsStruct.tptr8Val.size() / 2] = rsStruct.tptr8Val[nIndex]; //rsStruct.ptrssVal.resize(rsStruct.tptrssVal.size() * 2); //for (size_t nIndex = 0; nIndex < rsStruct.tptrssVal.size() / 2; nIndex++) // rsStruct.tptrssVal[nIndex + rsStruct.tptrssVal.size() / 2] = rsStruct.tptrssVal[nIndex]; //for (size_t nIndex = 0; nIndex < rsStruct.tptr8FixVal.size(); nIndex++) // rsStruct.tptr8FixVal[nIndex] = static_cast(rsStruct.tptr8FixVal[nIndex] << 1); //for (size_t nIndex = 0; nIndex < rsStruct.tptrssFixVal.size(); nIndex++) // rsStruct.ptrssFixVal[nIndex] = rsStruct.tptrssFixVal[nIndex] + rsStruct.tptrssFixVal[nIndex]; //rsStruct.tseq8Val.resize(rsStruct.tseq8Val.size() * 2); //for (size_t nIndex = 0; nIndex < rsStruct.tseq8Val.size() / 2; nIndex++) // rsStruct.tseq8Val[nIndex + rsStruct.tseq8Val.size() / 2] = rsStruct.tseq8Val[nIndex]; //rsStruct.tseqssVal.resize(rsStruct.tseqssVal.size() * 2); //for (size_t nIndex = 0; nIndex < rsStruct.tseqssVal.size() / 2; nIndex++) // rsStruct.seqssVal[nIndex + rsStruct.tseqssVal.size() / 2] = rsStruct.tseqssVal[nIndex]; //for (size_t nIndex = 0; nIndex < rsStruct.tseq8FixVal.size(); nIndex++) // rsStruct.tseq8FixVal[nIndex] = static_cast(rsStruct.tseq8FixVal[nIndex] << 1); //for (size_t nIndex = 0; nIndex < rsStruct.tseqssFixVal.size(); nIndex++) // rsStruct.tseqssFixVal[nIndex] = rsStruct.tseqssFixVal[nIndex] + rsStruct.tseqssFixVal[nIndex]; if (rsStruct.tifcVal.get() && rsStruct.tifcVal.id() == sdv::GetInterfaceId()) { m_summerTypedef.set(rsStruct.tifcVal.get()); rsStruct.tifcVal = static_cast(&m_summerTypedef); } else rsStruct.tifcVal = nullptr; // Typedef of interfaces current not possible. BUG #399464 //if (rsStruct.tpMultiplyValue) //{ // m_multiplierTypedef.set(rsStruct.tpMultiplyValue); // rsStruct.tpMultiplyValue = static_cast(&m_multiplierTypedef); //} //else // rsStruct.tpMultiplyValue = nullptr; rsStruct.tsSubVal.i += 1; rsStruct.tsIndVal.i += 10; // Incompatible serdes generation: BUG #398509 //rsStruct.tsUnnamedVal.i += 20; // Unnamed unions (inline definition) are not supported yet: PBI #398209 //union switch(int32) { case 0: int32 i; default: int32 j; } tuUnnamedVal; // Anonymous structs and unions (unnamed and no declaration) are not supported yet: PBI #397894 //struct { int32 iAnonymous1; int32 iAnonymous2; }; //union switch(int32) { case 0: int32 iAnonymous1; default: int32 iAnonymous2; }; } /** * @brief Update the mega union. This will test marshalling and unmarshalling of the mega union. Overload of * IMegaTest::ProcessMegaTypeBasedUnion. */ virtual void ProcessMegaTypeBasedUnion(/*inout*/ UMegaTypeBasedUnion& ruUnion) override { switch (ruUnion.get_switch()) { case 1: ruUnion.bVal = !ruUnion.bVal; break; case 2: ruUnion.sVal--; break; case 3: ruUnion.usVal++; break; case 4: ruUnion.lVal--; break; case 5: ruUnion.ulVal++; break; case 6: ruUnion.llVal--; break; case 7: ruUnion.ullVal++; break; case 8: ruUnion.i8Val--; break; case 9: ruUnion.ui8Val++; break; case 10: ruUnion.i16Val--; break; case 11: ruUnion.ui16Val++; break; case 12: ruUnion.i32Val--; break; case 13: ruUnion.ui32Val++; break; case 14: ruUnion.i64Val--; break; case 15: ruUnion.ui64Val++; break; case 16: ruUnion.cVal++; break; case 17: ruUnion.c16Val++; break; case 18: ruUnion.c32Val++; break; case 19: ruUnion.wcVal++; break; case 20: ruUnion.fVal -= 1000.000f; break; case 21: ruUnion.dVal += 1000.000; break; // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //case 22: ruUnion.ldVal -= 1000.000; break; case 23: ruUnion.nVal++; break; case 24: ruUnion.eHelloVal = ruUnion.eHelloVal++; break; case 25: if (ruUnion.idVal == sdv::GetInterfaceId()) ruUnion.idVal = sdv::GetInterfaceId(); else ruUnion.idVal = 0; break; case 26: ruUnion.ssVal += ruUnion.ssVal.empty() ? 'x' : ruUnion.ssVal.back() + 1; break; case 27: ruUnion.ss8Val += ruUnion.ss8Val.empty() ? 'x' : ruUnion.ss8Val.back() + 1; break; case 28: ruUnion.ss16Val += ruUnion.ss16Val.empty() ? u'x' : ruUnion.ss16Val.back() + 1; break; case 29: ruUnion.ss32Val += ruUnion.ss32Val.empty() ? U'x' : ruUnion.ss32Val.back() + 1; break; case 30: ruUnion.wssVal += ruUnion.wssVal.empty() ? L'x' : ruUnion.wssVal.back() + 1; break; case 31: ruUnion.ssFixVal += ruUnion.ssFixVal.empty() ? 'x' : ruUnion.ssFixVal.back() + 1; break; case 32: ruUnion.ss8FixVal += ruUnion.ss8FixVal.empty() ? 'x' : ruUnion.ss8FixVal.back() + 1; break; case 33: ruUnion.ss16FixVal += ruUnion.ss16FixVal.empty() ? u'x' : ruUnion.ss16FixVal.back() + 1; break; case 34: ruUnion.ss32FixVal += ruUnion.ss32FixVal.empty() ? U'x' : ruUnion.ss32FixVal.back() + 1; break; case 35: ruUnion.wssFixVal += ruUnion.wssFixVal.empty() ? L'x' : ruUnion.wssFixVal.back() + 1; break; case 36: ruUnion.ptr8Val.resize(ruUnion.ptr8Val.size() * 2); for (size_t nIndex = 0; nIndex < ruUnion.ptr8Val.size() / 2; nIndex++) ruUnion.ptr8Val[nIndex + ruUnion.ptr8Val.size() / 2] = ruUnion.ptr8Val[nIndex]; break; case 37: ruUnion.ptrssVal.resize(ruUnion.ptrssVal.size() * 2); for (size_t nIndex = 0; nIndex < ruUnion.ptrssVal.size() / 2; nIndex++) ruUnion.ptrssVal[nIndex + ruUnion.ptrssVal.size() / 2] = ruUnion.ptrssVal[nIndex]; break; case 38: for (size_t nIndex = 0; nIndex < ruUnion.ptr8FixVal.size(); nIndex++) ruUnion.ptr8FixVal[nIndex] = static_cast(ruUnion.ptr8FixVal[nIndex] << 1); break; case 39: for (size_t nIndex = 0; nIndex < ruUnion.ptrssFixVal.size(); nIndex++) ruUnion.ptrssFixVal[nIndex] = ruUnion.ptrssFixVal[nIndex] + ruUnion.ptrssFixVal[nIndex]; break; case 40: ruUnion.seq8Val.resize(ruUnion.seq8Val.size() * 2); for (size_t nIndex = 0; nIndex < ruUnion.seq8Val.size() / 2; nIndex++) ruUnion.seq8Val[nIndex + ruUnion.seq8Val.size() / 2] = ruUnion.seq8Val[nIndex]; break; case 41: ruUnion.seqssVal.resize(ruUnion.seqssVal.size() * 2); for (size_t nIndex = 0; nIndex < ruUnion.seqssVal.size() / 2; nIndex++) ruUnion.seqssVal[nIndex + ruUnion.seqssVal.size() / 2] = ruUnion.seqssVal[nIndex]; break; case 42: for (size_t nIndex = 0; nIndex < ruUnion.seq8FixVal.size(); nIndex++) ruUnion.seq8FixVal[nIndex] = static_cast(ruUnion.seq8FixVal[nIndex] << 1); break; case 43: for (size_t nIndex = 0; nIndex < ruUnion.seqssFixVal.size(); nIndex++) ruUnion.seqssFixVal[nIndex] = ruUnion.seqssFixVal[nIndex] + ruUnion.seqssFixVal[nIndex]; break; case 44: if (ruUnion.ifcVal.get() && ruUnion.ifcVal.id() == sdv::GetInterfaceId()) { m_summer.set(ruUnion.ifcVal.get()); ruUnion.ifcVal = static_cast(&m_summer); } else ruUnion.ifcVal = nullptr; break; case 45: if (ruUnion.pMultiplyValue) { m_multiplier.set(ruUnion.pMultiplyValue); ruUnion.pMultiplyValue = static_cast(&m_multiplier); } else ruUnion.pMultiplyValue = nullptr; break; case 46: ruUnion.sSubVal.i += 1; break; // Incompatible serdes generation: BUG #398509 //case 47: ruUnion.sIndVal.i += 10; break; // Unnamed struct inside unions are not supported yet: PBI #398230 //case 48: ruUnion.sUnnamedVal.i += 20; break; // Unnamed unions are not supported yet: PBI #398209 //case 49: union switch(int32) { case 0: int32 i; default: int32 j; } uUnnamedVal; // Anonymous structs and unions (unnamed and no declaration) are not supported yet: PBI #397894 //case 50: struct { int32 iAnonymous1; int32 iAnonymous2; }; //case 51: union switch(int32) { case 0: int32 iAnonymous1; default: int32 iAnonymous2; }; case 201: ruUnion.tbVal = !ruUnion.tbVal; break; case 202: ruUnion.tsVal--; break; case 203: ruUnion.tusVal++; break; case 204: ruUnion.tlVal--; break; case 205: ruUnion.tulVal++; break; case 206: ruUnion.tllVal--; break; case 207: ruUnion.tullVal++; break; case 208: ruUnion.ti8Val--; break; case 209: ruUnion.tui8Val++; break; case 210: ruUnion.ti16Val--; break; case 211: ruUnion.tui16Val++; break; case 212: ruUnion.ti32Val--; break; case 213: ruUnion.tui32Val++; break; case 214: ruUnion.ti64Val--; break; case 215: ruUnion.tui64Val++; break; case 216: ruUnion.tcVal++; break; case 217: ruUnion.tc16Val++; break; case 218: ruUnion.tc32Val++; break; case 219: ruUnion.twcVal++; break; case 220: ruUnion.tfVal -= 1000.000f; break; case 221: ruUnion.tdVal += 1000.000; break; // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //case 22: ruUnion.tldVal -= 1000.000; break; case 223: ruUnion.tnVal++; break; case 224: ruUnion.teHelloVal = ruUnion.teHelloVal++; break; case 225: if (ruUnion.tidVal == sdv::GetInterfaceId()) ruUnion.tidVal = sdv::GetInterfaceId(); else ruUnion.tidVal = 0; break; case 226: ruUnion.tssVal += ruUnion.tssVal.empty() ? 'x' : ruUnion.tssVal.back() + 1; break; case 227: ruUnion.tss8Val += ruUnion.tss8Val.empty() ? 'x' : ruUnion.tss8Val.back() + 1; break; case 228: ruUnion.tss16Val += ruUnion.tss16Val.empty() ? u'x' : ruUnion.tss16Val.back() + 1; break; case 229: ruUnion.tss32Val += ruUnion.tss32Val.empty() ? U'x' : ruUnion.tss32Val.back() + 1; break; case 230: ruUnion.twssVal += ruUnion.twssVal.empty() ? L'x' : ruUnion.twssVal.back() + 1; break; case 231: ruUnion.tssFixVal += ruUnion.tssFixVal.empty() ? 'x' : ruUnion.tssFixVal.back() + 1; break; case 232: ruUnion.tss8FixVal += ruUnion.tss8FixVal.empty() ? 'x' : ruUnion.tss8FixVal.back() + 1; break; case 233: ruUnion.tss16FixVal += ruUnion.tss16FixVal.empty() ? u'x' : ruUnion.tss16FixVal.back() + 1; break; case 234: ruUnion.tss32FixVal += ruUnion.tss32FixVal.empty() ? U'x' : ruUnion.tss32FixVal.back() + 1; break; case 235: ruUnion.twssFixVal += ruUnion.twssFixVal.empty() ? L'x' : ruUnion.twssFixVal.back() + 1; break; // Using typedefs of template based types produced an error: BUG #398266 //case 236: // ruUnion.tptr8Val.resize(ruUnion.tptr8Val.size() * 2); // for (size_t nIndex = 0; nIndex < ruUnion.tptr8Val.size() / 2; nIndex++) // ruUnion.tptr8Val[nIndex + ruUnion.tptr8Val.size() / 2] = ruUnion.tptr8Val[nIndex]; // break; //case 237: // ruUnion.tptrssVal.resize(ruUnion.tptrssVal.size() * 2); // for (size_t nIndex = 0; nIndex < ruUnion.tptrssVal.size() / 2; nIndex++) // ruUnion.tptrssVal[nIndex + ruUnion.tptrssVal.size() / 2] = ruUnion.tptrssVal[nIndex]; // break; //case 238: // for (size_t nIndex = 0; nIndex < ruUnion.tptr8FixVal.size(); nIndex++) // ruUnion.tptr8FixVal[nIndex] = static_cast(ruUnion.tptr8FixVal[nIndex] << 1); // break; //case 239: // for (size_t nIndex = 0; nIndex < ruUnion.tptrssFixVal.size(); nIndex++) // ruUnion.tptrssFixVal[nIndex] = ruUnion.tptrssFixVal[nIndex] + ruUnion.tptrssFixVal[nIndex]; // break; //case 240: // ruUnion.tseq8Val.resize(ruUnion.tseq8Val.size() * 2); // for (size_t nIndex = 0; nIndex < ruUnion.tseq8Val.size() / 2; nIndex++) // ruUnion.tseq8Val[nIndex + ruUnion.tseq8Val.size() / 2] = ruUnion.tseq8Val[nIndex]; // break; //case 241: // ruUnion.tseqssVal.resize(ruUnion.tseqssVal.size() * 2); // for (size_t nIndex = 0; nIndex < ruUnion.tseqssVal.size() / 2; nIndex++) // ruUnion.tseqssVal[nIndex + ruUnion.tseqssVal.size() / 2] = ruUnion.tseqssVal[nIndex]; // break; //case 242: // for (size_t nIndex = 0; nIndex < ruUnion.tseq8FixVal.size(); nIndex++) // ruUnion.tseq8FixVal[nIndex] = static_cast(ruUnion.tseq8FixVal[nIndex] << 1); // break; //case 243: // for (size_t nIndex = 0; nIndex < ruUnion.tseqssFixVal.size(); nIndex++) // ruUnion.tseqssFixVal[nIndex] = ruUnion.tseqssFixVal[nIndex] + ruUnion.tseqssFixVal[nIndex]; // break; case 244: if (ruUnion.tifcVal.get() && ruUnion.tifcVal.id() == sdv::GetInterfaceId()) { m_summerTypedef.set(ruUnion.tifcVal.get()); ruUnion.tifcVal = static_cast(&m_summerTypedef); } else ruUnion.tifcVal = nullptr; break; // Typedef of interfaces current not possible. BUG #399464 //case 245: // if (ruUnion.tpMultiplyValue) // { // m_multiplierTypedef.set(ruUnion.tpMultiplyValue); // ruUnion.tpMultiplyValue = static_cast(&m_multiplierTypedef); // } // else // ruUnion.tpMultiplyValue = nullptr; // break; case 246: ruUnion.tsSubVal.i += 1; break; // Incompatible serdes generation: BUG #398509 case 247: ruUnion.tsIndVal.i += 10; break; // Unnamed struct inside unions are not supported yet: PBI #398230 //case 248: ruUnion.tsUnnamedVal.i += 20; break; // Unnamed unions are not supported yet: PBI #398209 //case 249: union switch(int32) { case 0: int32 i; default: int32 j; } uUnnamedVal; // Anonymous structs and unions (unnamed and no declaration) are not supported yet: PBI #397894 //case 250: struct { int32 iAnonymous1; int32 iAnonymous2; }; //case 251: union switch(int32) { case 0: int32 iAnonymous1; default: int32 iAnonymous2; }; default: break; } } /** * @brief Update the mega union. This will test marshalling and unmarshalling of the mega union. Overload of * IMegaTest::ProcessMegaTypeBasedUnion. */ virtual void ProcessMegaVarBasedUnion(/*inout*/ SMegaVarBasedUnion& rsUnion) override { switch (rsUnion.get_switch()) { case 1: rsUnion.uVal.bVal = !rsUnion.uVal.bVal; break; case 2: rsUnion.uVal.sVal--; break; case 3: rsUnion.uVal.usVal++; break; case 4: rsUnion.uVal.lVal--; break; case 5: rsUnion.uVal.ulVal++; break; case 6: rsUnion.uVal.llVal--; break; case 7: rsUnion.uVal.ullVal++; break; case 8: rsUnion.uVal.i8Val--; break; case 9: rsUnion.uVal.ui8Val++; break; case 10: rsUnion.uVal.i16Val--; break; case 11: rsUnion.uVal.ui16Val++; break; case 12: rsUnion.uVal.i32Val--; break; case 13: rsUnion.uVal.ui32Val++; break; case 14: rsUnion.uVal.i64Val--; break; case 15: rsUnion.uVal.ui64Val++; break; case 16: rsUnion.uVal.cVal++; break; case 17: rsUnion.uVal.c16Val++; break; case 18: rsUnion.uVal.c32Val++; break; case 19: rsUnion.uVal.wcVal++; break; case 20: rsUnion.uVal.fVal -= 1000.000f; break; case 21: rsUnion.uVal.dVal += 1000.000; break; // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //case 22: rsUnion.uVal.ldVal -= 1000.000; break; case 23: rsUnion.uVal.nVal++; break; case 24: rsUnion.uVal.eHelloVal = rsUnion.uVal.eHelloVal++; break; case 25: if (rsUnion.uVal.idVal == sdv::GetInterfaceId()) rsUnion.uVal.idVal = sdv::GetInterfaceId(); else rsUnion.uVal.idVal = 0; break; case 26: rsUnion.uVal.ssVal += rsUnion.uVal.ssVal.empty() ? 'x' : rsUnion.uVal.ssVal.back() + 1; break; case 27: rsUnion.uVal.ss8Val += rsUnion.uVal.ss8Val.empty() ? 'x' : rsUnion.uVal.ss8Val.back() + 1; break; case 28: rsUnion.uVal.ss16Val += rsUnion.uVal.ss16Val.empty() ? u'x' : rsUnion.uVal.ss16Val.back() + 1; break; case 29: rsUnion.uVal.ss32Val += rsUnion.uVal.ss32Val.empty() ? U'x' : rsUnion.uVal.ss32Val.back() + 1; break; case 30: rsUnion.uVal.wssVal += rsUnion.uVal.wssVal.empty() ? L'x' : rsUnion.uVal.wssVal.back() + 1; break; case 31: rsUnion.uVal.ssFixVal += rsUnion.uVal.ssFixVal.empty() ? 'x' : rsUnion.uVal.ssFixVal.back() + 1; break; case 32: rsUnion.uVal.ss8FixVal += rsUnion.uVal.ss8FixVal.empty() ? 'x' : rsUnion.uVal.ss8FixVal.back() + 1; break; case 33: rsUnion.uVal.ss16FixVal += rsUnion.uVal.ss16FixVal.empty() ? u'x' : rsUnion.uVal.ss16FixVal.back() + 1; break; case 34: rsUnion.uVal.ss32FixVal += rsUnion.uVal.ss32FixVal.empty() ? U'x' : rsUnion.uVal.ss32FixVal.back() + 1; break; case 35: rsUnion.uVal.wssFixVal += rsUnion.uVal.wssFixVal.empty() ? L'x' : rsUnion.uVal.wssFixVal.back() + 1; break; case 36: rsUnion.uVal.ptr8Val.resize(rsUnion.uVal.ptr8Val.size() * 2); for (size_t nIndex = 0; nIndex < rsUnion.uVal.ptr8Val.size() / 2; nIndex++) rsUnion.uVal.ptr8Val[nIndex + rsUnion.uVal.ptr8Val.size() / 2] = rsUnion.uVal.ptr8Val[nIndex]; break; case 37: rsUnion.uVal.ptrssVal.resize(rsUnion.uVal.ptrssVal.size() * 2); for (size_t nIndex = 0; nIndex < rsUnion.uVal.ptrssVal.size() / 2; nIndex++) rsUnion.uVal.ptrssVal[nIndex + rsUnion.uVal.ptrssVal.size() / 2] = rsUnion.uVal.ptrssVal[nIndex]; break; case 38: for (size_t nIndex = 0; nIndex < rsUnion.uVal.ptr8FixVal.size(); nIndex++) rsUnion.uVal.ptr8FixVal[nIndex] = static_cast(rsUnion.uVal.ptr8FixVal[nIndex] << 1); break; case 39: for (size_t nIndex = 0; nIndex < rsUnion.uVal.ptrssFixVal.size(); nIndex++) rsUnion.uVal.ptrssFixVal[nIndex] = rsUnion.uVal.ptrssFixVal[nIndex] + rsUnion.uVal.ptrssFixVal[nIndex]; break; case 40: rsUnion.uVal.seq8Val.resize(rsUnion.uVal.seq8Val.size() * 2); for (size_t nIndex = 0; nIndex < rsUnion.uVal.seq8Val.size() / 2; nIndex++) rsUnion.uVal.seq8Val[nIndex + rsUnion.uVal.seq8Val.size() / 2] = rsUnion.uVal.seq8Val[nIndex]; break; case 41: rsUnion.uVal.seqssVal.resize(rsUnion.uVal.seqssVal.size() * 2); for (size_t nIndex = 0; nIndex < rsUnion.uVal.seqssVal.size() / 2; nIndex++) rsUnion.uVal.seqssVal[nIndex + rsUnion.uVal.seqssVal.size() / 2] = rsUnion.uVal.seqssVal[nIndex]; break; case 42: for (size_t nIndex = 0; nIndex < rsUnion.uVal.seq8FixVal.size(); nIndex++) rsUnion.uVal.seq8FixVal[nIndex] = static_cast(rsUnion.uVal.seq8FixVal[nIndex] << 1); break; case 43: for (size_t nIndex = 0; nIndex < rsUnion.uVal.seqssFixVal.size(); nIndex++) rsUnion.uVal.seqssFixVal[nIndex] = rsUnion.uVal.seqssFixVal[nIndex] + rsUnion.uVal.seqssFixVal[nIndex]; break; case 44: if (rsUnion.uVal.ifcVal.get() && rsUnion.uVal.ifcVal.id() == sdv::GetInterfaceId()) { m_summer.set(rsUnion.uVal.ifcVal.get()); rsUnion.uVal.ifcVal = static_cast(&m_summer); } else rsUnion.uVal.ifcVal = nullptr; break; case 45: if (rsUnion.uVal.pMultiplyValue) { m_multiplier.set(rsUnion.uVal.pMultiplyValue); rsUnion.uVal.pMultiplyValue = static_cast(&m_multiplier); } else rsUnion.uVal.pMultiplyValue = nullptr; break; case 46: rsUnion.uVal.sSubVal.i += 1; break; // Incompatible serdes generation: BUG #398509 //case 47: rsUnion.uVal.sIndVal.i += 10; break; // Unnamed struct inside unions are not supported yet: PBI #398230 //case 48: rsUnion.uVal.sUnnamedVal.i += 20; break; // Unnamed unions are not supported yet: PBI #398209 //case 49: union switch(int32) { case 0: int32 i; default: int32 j; } uUnnamedVal; // Anonymous structs and unions (unnamed and no declaration) are not supported yet: PBI #397894 //case 50: struct { int32 iAnonymous1; int32 iAnonymous2; }; //case 51: union switch(int32) { case 0: int32 iAnonymous1; default: int32 iAnonymous2; }; case 201: rsUnion.uVal.tbVal = !rsUnion.uVal.tbVal; break; case 202: rsUnion.uVal.tsVal--; break; case 203: rsUnion.uVal.tusVal++; break; case 204: rsUnion.uVal.tlVal--; break; case 205: rsUnion.uVal.tulVal++; break; case 206: rsUnion.uVal.tllVal--; break; case 207: rsUnion.uVal.tullVal++; break; case 208: rsUnion.uVal.ti8Val--; break; case 209: rsUnion.uVal.tui8Val++; break; case 210: rsUnion.uVal.ti16Val--; break; case 211: rsUnion.uVal.tui16Val++; break; case 212: rsUnion.uVal.ti32Val--; break; case 213: rsUnion.uVal.tui32Val++; break; case 214: rsUnion.uVal.ti64Val--; break; case 215: rsUnion.uVal.tui64Val++; break; case 216: rsUnion.uVal.tcVal++; break; case 217: rsUnion.uVal.tc16Val++; break; case 218: rsUnion.uVal.tc32Val++; break; case 219: rsUnion.uVal.twcVal++; break; case 220: rsUnion.uVal.tfVal -= 1000.000f; break; case 221: rsUnion.uVal.tdVal += 1000.000; break; // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //case 22: rsUnion.uVal.tldVal -= 1000.000; break; case 223: rsUnion.uVal.tnVal++; break; case 224: rsUnion.uVal.teHelloVal = rsUnion.uVal.teHelloVal++; break; case 225: if (rsUnion.uVal.tidVal == sdv::GetInterfaceId()) rsUnion.uVal.tidVal = sdv::GetInterfaceId(); else rsUnion.uVal.tidVal = 0; break; case 226: rsUnion.uVal.tssVal += rsUnion.uVal.tssVal.empty() ? 'x' : rsUnion.uVal.tssVal.back() + 1; break; case 227: rsUnion.uVal.tss8Val += rsUnion.uVal.tss8Val.empty() ? 'x' : rsUnion.uVal.tss8Val.back() + 1; break; case 228: rsUnion.uVal.tss16Val += rsUnion.uVal.tss16Val.empty() ? u'x' : rsUnion.uVal.tss16Val.back() + 1; break; case 229: rsUnion.uVal.tss32Val += rsUnion.uVal.tss32Val.empty() ? U'x' : rsUnion.uVal.tss32Val.back() + 1; break; case 230: rsUnion.uVal.twssVal += rsUnion.uVal.twssVal.empty() ? L'x' : rsUnion.uVal.twssVal.back() + 1; break; case 231: rsUnion.uVal.tssFixVal += rsUnion.uVal.tssFixVal.empty() ? 'x' : rsUnion.uVal.tssFixVal.back() + 1; break; case 232: rsUnion.uVal.tss8FixVal += rsUnion.uVal.tss8FixVal.empty() ? 'x' : rsUnion.uVal.tss8FixVal.back() + 1; break; case 233: rsUnion.uVal.tss16FixVal += rsUnion.uVal.tss16FixVal.empty() ? u'x' : rsUnion.uVal.tss16FixVal.back() + 1; break; case 234: rsUnion.uVal.tss32FixVal += rsUnion.uVal.tss32FixVal.empty() ? U'x' : rsUnion.uVal.tss32FixVal.back() + 1; break; case 235: rsUnion.uVal.twssFixVal += rsUnion.uVal.twssFixVal.empty() ? L'x' : rsUnion.uVal.twssFixVal.back() + 1; break; // Using typedefs of template based types produced an error: BUG #398266 //case 236: // rsUnion.uVal.tptr8Val.resize(rsUnion.uVal.tptr8Val.size() * 2); // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tptr8Val.size() / 2; nIndex++) // rsUnion.uVal.tptr8Val[nIndex + rsUnion.uVal.tptr8Val.size() / 2] = rsUnion.uVal.tptr8Val[nIndex]; // break; //case 237: // rsUnion.uVal.tptrssVal.resize(rsUnion.uVal.tptrssVal.size() * 2); // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tptrssVal.size() / 2; nIndex++) // rsUnion.uVal.tptrssVal[nIndex + rsUnion.uVal.tptrssVal.size() / 2] = rsUnion.uVal.tptrssVal[nIndex]; // break; //case 238: // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tptr8FixVal.size(); nIndex++) // rsUnion.uVal.tptr8FixVal[nIndex] = static_cast(rsUnion.uVal.tptr8FixVal[nIndex] << 1); // break; //case 239: // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tptrssFixVal.size(); nIndex++) // rsUnion.uVal.tptrssFixVal[nIndex] = rsUnion.uVal.tptrssFixVal[nIndex] + rsUnion.uVal.tptrssFixVal[nIndex]; // break; //case 240: // rsUnion.uVal.tseq8Val.resize(rsUnion.uVal.tseq8Val.size() * 2); // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tseq8Val.size() / 2; nIndex++) // rsUnion.uVal.tseq8Val[nIndex + rsUnion.uVal.tseq8Val.size() / 2] = rsUnion.uVal.tseq8Val[nIndex]; // break; //case 241: // rsUnion.uVal.tseqssVal.resize(rsUnion.uVal.tseqssVal.size() * 2); // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tseqssVal.size() / 2; nIndex++) // rsUnion.uVal.tseqssVal[nIndex + rsUnion.uVal.tseqssVal.size() / 2] = rsUnion.uVal.tseqssVal[nIndex]; // break; //case 242: // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tseq8FixVal.size(); nIndex++) // rsUnion.uVal.tseq8FixVal[nIndex] = static_cast(rsUnion.uVal.tseq8FixVal[nIndex] << 1); // break; //case 243: // for (size_t nIndex = 0; nIndex < rsUnion.uVal.tseqssFixVal.size(); nIndex++) // rsUnion.uVal.tseqssFixVal[nIndex] = rsUnion.uVal.tseqssFixVal[nIndex] + rsUnion.uVal.tseqssFixVal[nIndex]; // break; case 244: if (rsUnion.uVal.tifcVal.get() && rsUnion.uVal.tifcVal.id() == sdv::GetInterfaceId()) { m_summerTypedef.set(rsUnion.uVal.tifcVal.get()); rsUnion.uVal.tifcVal = static_cast(&m_summerTypedef); } else rsUnion.uVal.tifcVal = nullptr; break; // Typedef of interfaces current not possible. BUG #399464 //case 245: // if (rsUnion.uVal.tpMultiplyValue) // { // m_multiplierTypedef.set(rsUnion.uVal.tpMultiplyValue); // rsUnion.uVal.tpMultiplyValue = static_cast(&m_multiplierTypedef); // } // else // rsUnion.uVal.tpMultiplyValue = nullptr; // break; case 246: rsUnion.uVal.tsSubVal.i += 1; break; // Incompatible serdes generation: BUG #398509 case 247: rsUnion.uVal.tsIndVal.i += 10; break; // Unnamed struct inside unions are not supported yet: PBI #398230 //case 248: rsUnion.uVal.tsUnnamedVal.i += 20; break; // Unnamed unions are not supported yet: PBI #398209 //case 249: union switch(int32) { case 0: int32 i; default: int32 j; } uUnnamedVal; // Anonymous structs and unions (unnamed and no declaration) are not supported yet: PBI #397894 //case 250: struct { int32 iAnonymous1; int32 iAnonymous2; }; //case 251: union switch(int32) { case 0: int32 iAnonymous1; default: int32 iAnonymous2; }; default: break; } } ISayHello* m_pHello = nullptr; struct SInternalMultiply : IMultiplyValue { void set(IMultiplyValue* p) { pMultiplyValue = p; } size_t Multiply(size_t n) { if (!pMultiplyValue) return 0; return pMultiplyValue->Multiply(n) * pMultiplyValue->Multiply(n); } IMultiplyValue* pMultiplyValue = nullptr; }; SInternalMultiply m_multiplier; SInternalMultiply m_multiplierTypedef; struct SInternalAdd : IAddValue { void set(IMultiplyValue* p) { pMultiplyValue = p; } size_t Add(size_t n) { if (!pMultiplyValue) return 0; return pMultiplyValue->Multiply(n) + pMultiplyValue->Multiply(n); } IMultiplyValue* pMultiplyValue = nullptr; }; SInternalAdd m_summer; SInternalAdd m_summerTypedef; }; void LoadIPCModules(CCommunicationControl& rControl) { // Load the IPC modules sdv::core::IModuleControl* pModuleControl = sdv::core::GetObject("ModuleControlService"); ASSERT_NE(pModuleControl, nullptr); EXPECT_NE(pModuleControl->Load("ipc_shared_mem.sdv"), 0u); EXPECT_NE(pModuleControl->Load("core_ps.sdv"), 0u); EXPECT_NE(pModuleControl->Load("UnitTest_IPC_Communication_ps.sdv"), 0u); // Create the services sdv::core::IRepositoryControl* pRepositoryControl = sdv::core::GetObject("RepositoryService"); ASSERT_NE(pRepositoryControl, nullptr); EXPECT_NE(pRepositoryControl->CreateObject("DefaultSharedMemoryChannelControl", {}, {}), 0u); // Register the communication control service sdv::core::IRegisterForeignObject* pRegisterObject = sdv::core::GetObject("RepositoryService"); ASSERT_NE(pRegisterObject, nullptr); EXPECT_NE(pRegisterObject->RegisterObject(&rControl, "CommunicationControl"), 0u); } TEST(IPC_Communication_Test, Instantiate) { CCommunicationControl control; EXPECT_NO_THROW(control.Initialize("")); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); EXPECT_NO_THROW(control.Shutdown()); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::destruction_pending); } TEST(IPC_Communication_Test, AssignServerEndpoint) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create a channel endpoint sdv::ipc::ICreateEndpoint* ptrCreateEndpoint = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(ptrCreateEndpoint, nullptr); sdv::ipc::SChannelEndpoint sChannelEndpoint = ptrCreateEndpoint->CreateEndpoint(""); EXPECT_NE(sChannelEndpoint.pConnection, nullptr); EXPECT_FALSE(sChannelEndpoint.ssConnectString.empty()); sdv::TObjectPtr ptrEndpoint = sChannelEndpoint.pConnection; // Automatic lifetime management EXPECT_TRUE(ptrEndpoint); // Assign the server endpoint CInterfaceTest test; EXPECT_TRUE(control.AssignServerEndpoint(ptrEndpoint, &test, 100, false) != 0u); ptrEndpoint.Clear(); // Lifetime taken over by communication control. // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, AssignClientEndpoint) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create a server endpoint sdv::ipc::ICreateEndpoint* ptrCreateEndpoint = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(ptrCreateEndpoint, nullptr); sdv::ipc::SChannelEndpoint sChannelEndpoint = ptrCreateEndpoint->CreateEndpoint(""); EXPECT_NE(sChannelEndpoint.pConnection, nullptr); EXPECT_FALSE(sChannelEndpoint.ssConnectString.empty()); sdv::TObjectPtr ptrServerEndpoint = sChannelEndpoint.pConnection; // Automatic lifetime management EXPECT_TRUE(ptrServerEndpoint); // Create a client endpoint sdv::ipc::IChannelAccess* pChannelAccess = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(pChannelAccess, nullptr); sdv::TObjectPtr ptrClientEndpoint = pChannelAccess->Access(sChannelEndpoint.ssConnectString); EXPECT_TRUE(ptrClientEndpoint); // Assign the server and client endpoints CInterfaceTest test; EXPECT_TRUE(control.AssignServerEndpoint(ptrServerEndpoint, &test, 100, false) != 0u); sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.AssignClientEndpoint(ptrClientEndpoint, 1000, pObjectProxy) != 0u); EXPECT_NE(pObjectProxy, nullptr); ptrServerEndpoint.Clear(); // Lifetime taken over by communication control. ptrClientEndpoint.Clear(); // Lifetime taken over by communication control. // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Disabled the following test due to an unidentified crash/heap corruption occurring with MINGW on the build-server. // Bug-report #610009 describes this issue: https://dev.azure.com/SW4ZF/AZP-074_DivDI_SofDCarResearch/_workitems/edit/610009 //#ifdef _WIN32 TEST(IPC_Communication_Test, DISABLED_AssignClientEndpoint_Reconnect) //#else //TEST(IPC_Communication_Test, AssignClientEndpoint_Reconnect) //#endif { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create a server endpoint sdv::ipc::ICreateEndpoint* ptrCreateEndpoint = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(ptrCreateEndpoint, nullptr); sdv::ipc::SChannelEndpoint sChannelEndpoint = ptrCreateEndpoint->CreateEndpoint(""); EXPECT_NE(sChannelEndpoint.pConnection, nullptr); EXPECT_FALSE(sChannelEndpoint.ssConnectString.empty()); sdv::TObjectPtr ptrServerEndpoint = sChannelEndpoint.pConnection; // Automatic lifetime management EXPECT_TRUE(ptrServerEndpoint); // Create a client endpoint sdv::ipc::IChannelAccess* pChannelAccess = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(pChannelAccess, nullptr); sdv::TObjectPtr ptrClientEndpoint = pChannelAccess->Access(sChannelEndpoint.ssConnectString); EXPECT_TRUE(ptrClientEndpoint); // Assign the server and client endpoints CInterfaceTest test; EXPECT_TRUE(control.AssignServerEndpoint(ptrServerEndpoint, &test, 100, true) != 0u); ptrServerEndpoint.Clear(); // Lifetime taken over by communication control. sdv::IInterfaceAccess* pObjectProxy = nullptr; sdv::com::TConnectionID tConnectionID = control.AssignClientEndpoint(ptrClientEndpoint, 1000, pObjectProxy); EXPECT_TRUE(tConnectionID != 0u); EXPECT_NE(pObjectProxy, nullptr); // Disconnect from the client sdv::ipc::IConnect* pClientConnect = ptrClientEndpoint.GetInterface(); ASSERT_NE(pClientConnect, nullptr); EXPECT_EQ(pClientConnect->GetConnectState(), sdv::ipc::EConnectState::connected); control.RemoveConnection(tConnectionID); EXPECT_EQ(pClientConnect->GetConnectState(), sdv::ipc::EConnectState::disconnected); ptrClientEndpoint.Clear(); // Lifetime taken over by communication control. // Create another client endpoint ptrClientEndpoint = pChannelAccess->Access(sChannelEndpoint.ssConnectString); EXPECT_TRUE(ptrClientEndpoint); // Assign the new client endpoint pObjectProxy = nullptr; tConnectionID = control.AssignClientEndpoint(ptrClientEndpoint, 1000, pObjectProxy); EXPECT_TRUE(tConnectionID != 0u); EXPECT_NE(pObjectProxy, nullptr); ptrClientEndpoint.Clear(); // Lifetime taken over by communication control. // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, AssignClientEndpoint_FailReconnect) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create a server endpoint sdv::ipc::ICreateEndpoint* ptrCreateEndpoint = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(ptrCreateEndpoint, nullptr); sdv::ipc::SChannelEndpoint sChannelEndpoint = ptrCreateEndpoint->CreateEndpoint(""); EXPECT_NE(sChannelEndpoint.pConnection, nullptr); EXPECT_FALSE(sChannelEndpoint.ssConnectString.empty()); sdv::TObjectPtr ptrServerEndpoint = sChannelEndpoint.pConnection; // Automatic lifetime management EXPECT_TRUE(ptrServerEndpoint); // Create a client endpoint sdv::ipc::IChannelAccess* pChannelAccess = sdv::core::GetObject("LocalChannelControl"); ASSERT_NE(pChannelAccess, nullptr); sdv::TObjectPtr ptrClientEndpoint = pChannelAccess->Access(sChannelEndpoint.ssConnectString); EXPECT_TRUE(ptrClientEndpoint); // Assign the server and client endpoints CInterfaceTest test; EXPECT_TRUE(control.AssignServerEndpoint(ptrServerEndpoint, &test, 100, false) != 0u); ptrServerEndpoint.Clear(); // Lifetime taken over by communication control. sdv::IInterfaceAccess* pObjectProxy = nullptr; sdv::com::TConnectionID tConnectionID = control.AssignClientEndpoint(ptrClientEndpoint, 1000, pObjectProxy); EXPECT_TRUE(tConnectionID != 0u); EXPECT_NE(pObjectProxy, nullptr); // Disconnect from the client sdv::ipc::IConnect* pClientConnect = ptrClientEndpoint.GetInterface(); ASSERT_NE(pClientConnect, nullptr); EXPECT_EQ(pClientConnect->GetConnectState(), sdv::ipc::EConnectState::connected); control.RemoveConnection(tConnectionID); EXPECT_EQ(pClientConnect->GetConnectState(), sdv::ipc::EConnectState::disconnected); ptrClientEndpoint.Clear(); // Lifetime taken over by communication control. // Create another client endpoint ptrClientEndpoint = pChannelAccess->Access(sChannelEndpoint.ssConnectString); EXPECT_TRUE(ptrClientEndpoint); // Assign the new client endpoint - this should fail! pObjectProxy = nullptr; tConnectionID = control.AssignClientEndpoint(ptrClientEndpoint, 1000, pObjectProxy); EXPECT_TRUE(tConnectionID == 0u); EXPECT_EQ(pObjectProxy, nullptr); ptrClientEndpoint.Clear(); // Lifetime taken over by communication control. // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, CreateServerConnection) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, CreateClientConnection) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); EXPECT_NE(pObjectProxy, nullptr); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, CreateClientConnection_FailReconnect) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; sdv::com::TConnectionID tConnectionID = control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy); EXPECT_TRUE(tConnectionID != 0u); EXPECT_NE(pObjectProxy, nullptr); // Disconnect from the client control.RemoveConnection(tConnectionID); // Create a new client connection pObjectProxy = nullptr; tConnectionID = control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy); EXPECT_TRUE(tConnectionID == 0u); EXPECT_EQ(pObjectProxy, nullptr); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallClientToServer) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Request the ISayHello interface ISayHello* pSayHello = nullptr; EXPECT_NO_THROW(pSayHello = pObjectProxy->GetInterface()); ASSERT_NE(pSayHello, nullptr); EXPECT_EQ(pSayHello->Hello(), "Hello"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallInterfaceFromServer) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Request the IRequestHello interface IRequestHello* pRequestHello = nullptr; EXPECT_NO_THROW(pRequestHello = pObjectProxy->GetInterface()); ASSERT_NE(pRequestHello, nullptr); // Request the ISayHello interface ISayHello* pSayHello = pRequestHello->Request(); // Call the interface as if talking from the client ASSERT_NE(pSayHello, nullptr); EXPECT_EQ(pSayHello->Hello(), "Hello"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallInterfaceFromClient) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Request the IRegisterHelloCallback interface IRegisterHelloCallback* pRegisterHelloCallback = nullptr; EXPECT_NO_THROW(pRegisterHelloCallback = pObjectProxy->GetInterface()); ASSERT_NE(pRegisterHelloCallback, nullptr); // Register the callback (stored in the object) pRegisterHelloCallback->Register(&test); // Call the interface as if talking from the server ASSERT_NE(test.m_pHello, nullptr); EXPECT_EQ(test.m_pHello->Hello(), "Hello"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallGenericInterfaceFromServer) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Request the IRegisterHelloCallback interface sdv::IInterfaceAccess* pRegisterHelloCallback = nullptr; EXPECT_NO_THROW(pRegisterHelloCallback = pObjectProxy->GetInterface()); ASSERT_NE(pRegisterHelloCallback, nullptr); // Call GetInterface to get the IInterfaceAccess pointer once more (to be able to test marshalling). sdv::IInterfaceAccess* pInterfaceAccess = pObjectProxy->GetInterface(); ASSERT_NE(pInterfaceAccess, nullptr); // Request the pSayHello interface (this will be marshalled as well) ISayHello* pSayHello = pInterfaceAccess->GetInterface(); // Call the interface as if talking from the client ASSERT_NE(pSayHello, nullptr); EXPECT_EQ(pSayHello->Hello(), "Hello"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructBoolean) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.bVal = false; EXPECT_FALSE(sStruct.bVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_TRUE(sStruct.bVal); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructIntegral) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.sVal = -10; sStruct.usVal = 10; sStruct.lVal = -20; sStruct.ulVal = 20; sStruct.llVal = -30; sStruct.ullVal = 30; sStruct.i8Val = -40; sStruct.ui8Val = 40; sStruct.i16Val = -50; sStruct.ui16Val = 50; sStruct.i32Val = -60; sStruct.ui32Val = 60; sStruct.i64Val = -70; sStruct.ui64Val = 70; sStruct.nVal = 80; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.sVal, -11); EXPECT_EQ(sStruct.usVal, 11u); EXPECT_EQ(sStruct.lVal, -21); EXPECT_EQ(sStruct.ulVal, 21u); EXPECT_EQ(sStruct.llVal, -31); EXPECT_EQ(sStruct.ullVal, 31u); EXPECT_EQ(static_cast(sStruct.i8Val), static_cast(-41)); // Cast needed for ARM compatibility EXPECT_EQ(sStruct.ui8Val, 41u); EXPECT_EQ(sStruct.i16Val, -51); EXPECT_EQ(sStruct.ui16Val, 51u); EXPECT_EQ(sStruct.i32Val, -61); EXPECT_EQ(sStruct.ui32Val, 61u); EXPECT_EQ(sStruct.i64Val, -71); EXPECT_EQ(sStruct.ui64Val, 71u); EXPECT_EQ(sStruct.nVal, 81); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructCharacter) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.cVal = 'A'; sStruct.c16Val = u'D'; sStruct.c32Val = U'G'; sStruct.wcVal = L'J'; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.cVal, 'B'); EXPECT_EQ(sStruct.c16Val, u'E'); EXPECT_EQ(sStruct.c32Val, U'H'); EXPECT_EQ(sStruct.wcVal, L'K'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructFloatingPoint) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; float fVal = -1234.5678f; sStruct.fVal = fVal; double dVal = 8765.4321; sStruct.dVal = dVal; long double ldVal = -1234.4321; sStruct.ldVal = ldVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.fVal, fVal - 1000.000f); EXPECT_EQ(sStruct.dVal, dVal + 1000.000); EXPECT_EQ(sStruct.ldVal, ldVal - 1000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructEnum) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.eHelloVal = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.eHelloVal, EHello::hallo); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructString) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.ssVal = "hi"; sStruct.ss8Val = "huhu"; sStruct.ss16Val = u"hey"; sStruct.ss32Val = U"hello"; sStruct.wssVal = L"servus"; sStruct.ssFixVal = "hi"; sStruct.ss8FixVal = "huhu"; sStruct.ss16FixVal = u"hey"; sStruct.ss32FixVal = U"hello"; sStruct.wssFixVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.ssVal, "hij"); EXPECT_EQ(sStruct.ss8Val, "huhuv"); EXPECT_EQ(sStruct.ss16Val, u"heyz"); EXPECT_EQ(sStruct.ss32Val, U"hellop"); EXPECT_EQ(sStruct.wssVal, L"servust"); EXPECT_EQ(sStruct.ssFixVal, "hij"); EXPECT_EQ(sStruct.ss8FixVal, "huhuv"); EXPECT_EQ(sStruct.ss16FixVal, u"heyz"); EXPECT_EQ(sStruct.ss32FixVal, U"hellop"); EXPECT_EQ(sStruct.wssFixVal, L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructPointer) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.ptr8Val.resize(100); for (size_t nIndex = 0; nIndex < sStruct.ptr8Val.size(); nIndex++) sStruct.ptr8Val[nIndex] = static_cast(nIndex); sStruct.ptrssVal.resize(3); sStruct.ptrssVal[0] = "hello"; sStruct.ptrssVal[1] = "huhu"; sStruct.ptrssVal[2] = "hi"; sStruct.ptr8FixVal.resize(sStruct.ptr8FixVal.capacity()); for (size_t nIndex = 0; nIndex < sStruct.ptr8FixVal.size(); nIndex++) sStruct.ptr8FixVal[nIndex] = static_cast(nIndex); sStruct.ptrssFixVal.resize(sStruct.ptrssFixVal.capacity()); sStruct.ptrssFixVal[0] = "hi"; sStruct.ptrssFixVal[1] = "hoi"; sStruct.ptrssFixVal[2] = "hello"; sStruct.ptrssFixVal[3] = "hallo"; sStruct.ptrssFixVal[4] = "servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.ptr8Val.size(), 200); for (size_t nIndex = 0; nIndex < sStruct.ptr8Val.size() / 2; nIndex++) EXPECT_EQ(sStruct.ptr8Val[nIndex], sStruct.ptr8Val[nIndex + sStruct.ptr8Val.size() / 2]); EXPECT_EQ(sStruct.ptrssVal.size(), 6); for (size_t nIndex = 0; nIndex < sStruct.ptrssVal.size() / 2; nIndex++) EXPECT_EQ(sStruct.ptrssVal[nIndex], sStruct.ptrssVal[nIndex + sStruct.ptrssVal.size() / 2]); EXPECT_EQ(sStruct.ptr8FixVal.size(), 20); for (size_t nIndex = 0; nIndex < sStruct.ptr8FixVal.size(); nIndex++) EXPECT_EQ(sStruct.ptr8FixVal[nIndex], static_cast(nIndex << 1)); EXPECT_EQ(sStruct.ptrssFixVal.size(), 5); EXPECT_EQ(sStruct.ptrssFixVal[0], "hihi"); EXPECT_EQ(sStruct.ptrssFixVal[1], "hoihoi"); EXPECT_EQ(sStruct.ptrssFixVal[2], "hellohello"); EXPECT_EQ(sStruct.ptrssFixVal[3], "hallohallo"); EXPECT_EQ(sStruct.ptrssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructSequence) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.seq8Val.resize(100); for (size_t nIndex = 0; nIndex < sStruct.seq8Val.size(); nIndex++) sStruct.seq8Val[nIndex] = static_cast(nIndex); sStruct.seqssVal.resize(3); sStruct.seqssVal[0] = "hello"; sStruct.seqssVal[1] = "huhu"; sStruct.seqssVal[2] = "hi"; sStruct.seq8FixVal.resize(sStruct.seq8FixVal.capacity()); for (size_t nIndex = 0; nIndex < sStruct.seq8FixVal.size(); nIndex++) sStruct.seq8FixVal[nIndex] = static_cast(nIndex); sStruct.seqssFixVal.resize(sStruct.seqssFixVal.capacity()); sStruct.seqssFixVal[0] = "hi"; sStruct.seqssFixVal[1] = "hoi"; sStruct.seqssFixVal[2] = "hello"; sStruct.seqssFixVal[3] = "hallo"; sStruct.seqssFixVal[4] = "servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.seq8Val.size(), 200); for (size_t nIndex = 0; nIndex < sStruct.seq8Val.size() / 2; nIndex++) EXPECT_EQ(sStruct.seq8Val[nIndex], sStruct.seq8Val[nIndex + sStruct.seq8Val.size() / 2]); EXPECT_EQ(sStruct.seqssVal.size(), 6); for (size_t nIndex = 0; nIndex < sStruct.seqssVal.size() / 2; nIndex++) EXPECT_EQ(sStruct.seqssVal[nIndex], sStruct.seqssVal[nIndex + sStruct.seqssVal.size() / 2]); EXPECT_EQ(sStruct.seq8FixVal.size(), 20); for (size_t nIndex = 0; nIndex < sStruct.seq8FixVal.size(); nIndex++) EXPECT_EQ(sStruct.seq8FixVal[nIndex], static_cast(nIndex << 1)); EXPECT_EQ(sStruct.seqssFixVal.size(), 5); EXPECT_EQ(sStruct.seqssFixVal[0], "hihi"); EXPECT_EQ(sStruct.seqssFixVal[1], "hoihoi"); EXPECT_EQ(sStruct.seqssFixVal[2], "hellohello"); EXPECT_EQ(sStruct.seqssFixVal[3], "hallohallo"); EXPECT_EQ(sStruct.seqssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructInterface) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.idVal = sdv::GetInterfaceId(); sStruct.ifcVal = static_cast(&sMultiply); sStruct.pMultiplyValue = &sMultiply; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.idVal, sdv::GetInterfaceId()); EXPECT_EQ(sStruct.ifcVal.id(), sdv::GetInterfaceId()); ASSERT_NE(sStruct.ifcVal, nullptr); ASSERT_NE(sStruct.ifcVal.get(), nullptr); EXPECT_EQ(sStruct.ifcVal.get()->Add(99), 19602); // 99 * 99 + 99 * 99 ASSERT_NE(sStruct.pMultiplyValue, nullptr); EXPECT_EQ(sStruct.pMultiplyValue->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructSubCompound) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.sSubVal.i = 1; sStruct.sIndVal.i = 10; //sStruct.sUnnamedVal.i = 100; // 12.04.2024 EVE Unnamed structures are not supported by IDL compiler. EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.sSubVal.i, 2); EXPECT_EQ(sStruct.sIndVal.i, 20); //EXPECT_EQ(sStruct.sUnnamedVal.i, 120); // 12.04.2024 EVE Unnamed structures are not supported by IDL compiler. // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructBooleanArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgbVal[0] = false; sStruct.rgbVal[1] = true; EXPECT_FALSE(sStruct.bVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_TRUE(sStruct.rgbVal[0]); EXPECT_FALSE(sStruct.rgbVal[1]); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructIntegralArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgsVal[0] = -10; sStruct.rgsVal[1] = -11; sStruct.rgusVal[0] = 10; sStruct.rgusVal[1] = 11; sStruct.rglVal[0] = -20; sStruct.rglVal[1] = -21; sStruct.rgulVal[0] = 20; sStruct.rgulVal[1] = 21; sStruct.rgllVal[0] = -30; sStruct.rgllVal[1] = -31; sStruct.rgullVal[0] = 30; sStruct.rgullVal[1] = 31; sStruct.rgi8Val[0] = -40; sStruct.rgi8Val[1] = -41; sStruct.rgui8Val[0] = 40; sStruct.rgui8Val[1] = 41; sStruct.rgi16Val[0] = -50; sStruct.rgi16Val[1] = -51; sStruct.rgui16Val[0] = 50; sStruct.rgui16Val[1] = 51; sStruct.rgi32Val[0] = -60; sStruct.rgi32Val[1] = -61; sStruct.rgui32Val[0] = 60; sStruct.rgui32Val[1] = 61; sStruct.rgi64Val[0] = -70; sStruct.rgi64Val[1] = -71; sStruct.rgui64Val[0] = 70; sStruct.rgui64Val[1] = 71; sStruct.rgnVal[0] = 80; sStruct.rgnVal[1] = 81; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgsVal[0], -11); EXPECT_EQ(sStruct.rgsVal[1], -10); EXPECT_EQ(sStruct.rgusVal[0], 11u); EXPECT_EQ(sStruct.rgusVal[1], 13u); EXPECT_EQ(sStruct.rglVal[0], -21); EXPECT_EQ(sStruct.rglVal[1], -20); EXPECT_EQ(sStruct.rgulVal[0], 21u); EXPECT_EQ(sStruct.rgulVal[1], 23u); EXPECT_EQ(sStruct.rgllVal[0], -31); EXPECT_EQ(sStruct.rgllVal[1], -30); EXPECT_EQ(sStruct.rgullVal[0], 31u); EXPECT_EQ(sStruct.rgullVal[1], 33u); EXPECT_EQ(static_cast(sStruct.rgi8Val[0]), static_cast(-41)); // Cast needed for ARM compatibility EXPECT_EQ(static_cast(sStruct.rgi8Val[1]), static_cast(-40)); // Cast needed for ARM compatibility EXPECT_EQ(sStruct.rgui8Val[0], 41u); EXPECT_EQ(sStruct.rgui8Val[1], 43u); EXPECT_EQ(sStruct.rgi16Val[0], -51); EXPECT_EQ(sStruct.rgi16Val[1], -50); EXPECT_EQ(sStruct.rgui16Val[0], 51u); EXPECT_EQ(sStruct.rgui16Val[1], 53u); EXPECT_EQ(sStruct.rgi32Val[0], -61); EXPECT_EQ(sStruct.rgi32Val[1], -60); EXPECT_EQ(sStruct.rgui32Val[0], 61u); EXPECT_EQ(sStruct.rgui32Val[1], 63u); EXPECT_EQ(sStruct.rgi64Val[0], -71); EXPECT_EQ(sStruct.rgi64Val[1], -70); EXPECT_EQ(sStruct.rgui64Val[0], 71u); EXPECT_EQ(sStruct.rgui64Val[1], 73u); EXPECT_EQ(sStruct.rgnVal[0], 81); EXPECT_EQ(sStruct.rgnVal[1], 83); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructCharacterArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgcVal[0] = 'A'; sStruct.rgcVal[1] = 'B'; sStruct.rgc16Val[0] = u'D'; sStruct.rgc16Val[1] = u'E'; sStruct.rgc32Val[0] = U'G'; sStruct.rgc32Val[1] = U'H'; sStruct.rgwcVal[0] = L'J'; sStruct.rgwcVal[1] = L'K'; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgcVal[0], 'B'); EXPECT_EQ(sStruct.rgcVal[1], 'D'); EXPECT_EQ(sStruct.rgc16Val[0], u'E'); EXPECT_EQ(sStruct.rgc16Val[1], u'G'); EXPECT_EQ(sStruct.rgc32Val[0], U'H'); EXPECT_EQ(sStruct.rgc32Val[1], U'J'); EXPECT_EQ(sStruct.rgwcVal[0], L'K'); EXPECT_EQ(sStruct.rgwcVal[1], L'M'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructFloatingPointArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; float fVal = -1234.5678f; sStruct.rgfVal[0] = fVal; sStruct.rgfVal[1] = fVal; double dVal = 8765.4321; sStruct.rgdVal[0] = dVal; sStruct.rgdVal[1] = dVal; long double ldVal = -1234.4321; sStruct.rgldVal[0] = ldVal; sStruct.rgldVal[1] = ldVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgfVal[0], fVal - 1000.000f); EXPECT_EQ(sStruct.rgfVal[1], fVal + 2000.000f); EXPECT_EQ(sStruct.rgdVal[0], dVal + 1000.000); EXPECT_EQ(sStruct.rgdVal[1], dVal - 2000.000); EXPECT_EQ(sStruct.rgldVal[0], ldVal - 1000.000); EXPECT_EQ(sStruct.rgldVal[1], ldVal + 2000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructEnumArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgeHelloVal[0] = EHello::hello; sStruct.rgeHelloVal[1] = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgeHelloVal[0], EHello::hallo); EXPECT_EQ(sStruct.rgeHelloVal[1], EHello::huhu); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructStringArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgssVal[0] = "hi"; sStruct.rgssVal[1] = "hi"; sStruct.rgss8Val[0] = "huhu"; sStruct.rgss8Val[1] = "huhu"; sStruct.rgss16Val[0] = u"hey"; sStruct.rgss16Val[1] = u"hey"; sStruct.rgss32Val[0] = U"hello"; sStruct.rgss32Val[1] = U"hello"; sStruct.rgwssVal[0] = L"servus"; sStruct.rgwssVal[1] = L"servus"; sStruct.rgssFixVal[0] = "hi"; sStruct.rgssFixVal[1] = "hi"; sStruct.rgss8FixVal[0] = "huhu"; sStruct.rgss8FixVal[1] = "huhu"; sStruct.rgss16FixVal[0] = u"hey"; sStruct.rgss16FixVal[1] = u"hey"; sStruct.rgss32FixVal[0] = U"hello"; sStruct.rgss32FixVal[1] = U"hello"; sStruct.rgwssFixVal[0] = L"servus"; sStruct.rgwssFixVal[1] = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgssVal[0], "hij"); EXPECT_EQ(sStruct.rgssVal[1], "hii"); EXPECT_EQ(sStruct.rgss8Val[0], "huhuv"); EXPECT_EQ(sStruct.rgss8Val[1], "huhui"); EXPECT_EQ(sStruct.rgss16Val[0], u"heyz"); EXPECT_EQ(sStruct.rgss16Val[1], u"heyi"); EXPECT_EQ(sStruct.rgss32Val[0], U"hellop"); EXPECT_EQ(sStruct.rgss32Val[1], U"helloi"); EXPECT_EQ(sStruct.rgwssVal[0], L"servust"); EXPECT_EQ(sStruct.rgwssVal[1], L"servust"); EXPECT_EQ(sStruct.rgssFixVal[0], "hij"); EXPECT_EQ(sStruct.rgssFixVal[1], "hii"); EXPECT_EQ(sStruct.rgss8FixVal[0], "huhuv"); EXPECT_EQ(sStruct.rgss8FixVal[1], "huhui"); EXPECT_EQ(sStruct.rgss16FixVal[0], u"heyz"); EXPECT_EQ(sStruct.rgss16FixVal[1], u"heyi"); EXPECT_EQ(sStruct.rgss32FixVal[0], U"hellop"); EXPECT_EQ(sStruct.rgss32FixVal[1], U"helloi"); EXPECT_EQ(sStruct.rgwssFixVal[0], L"servust"); EXPECT_EQ(sStruct.rgwssFixVal[1], L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructPointerArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgptr8Val[0].resize(100); sStruct.rgptr8Val[1].resize(100); for (size_t nIndex = 0; nIndex < sStruct.rgptr8Val[0].size(); nIndex++) sStruct.rgptr8Val[0][nIndex] = static_cast(nIndex); for (size_t nIndex = 0; nIndex < sStruct.rgptr8Val[1].size(); nIndex++) sStruct.rgptr8Val[1][nIndex] = static_cast(nIndex); sStruct.rgptrssVal[0].resize(3); sStruct.rgptrssVal[1].resize(3); sStruct.rgptrssVal[0][0] = "hello"; sStruct.rgptrssVal[1][0] = "ohhello"; sStruct.rgptrssVal[0][1] = "huhu"; sStruct.rgptrssVal[1][1] = "ohhuhu"; sStruct.rgptrssVal[0][2] = "hi"; sStruct.rgptrssVal[1][2] = "ohhi"; sStruct.rgptr8FixVal[0].resize(sStruct.rgptr8FixVal[0].capacity()); sStruct.rgptr8FixVal[1].resize(sStruct.rgptr8FixVal[1].capacity()); for (size_t nIndex = 0; nIndex < sStruct.rgptr8FixVal[0].size(); nIndex++) sStruct.rgptr8FixVal[0][nIndex] = static_cast(nIndex); for (size_t nIndex = 0; nIndex < sStruct.rgptr8FixVal[1].size(); nIndex++) sStruct.rgptr8FixVal[1][nIndex] = static_cast(nIndex); sStruct.rgptrssFixVal[0].resize(sStruct.rgptrssFixVal[0].capacity()); sStruct.rgptrssFixVal[1].resize(sStruct.rgptrssFixVal[1].capacity()); sStruct.rgptrssFixVal[0][0] = "hi"; sStruct.rgptrssFixVal[1][0] = "ohhi"; sStruct.rgptrssFixVal[0][1] = "hoi"; sStruct.rgptrssFixVal[1][1] = "ohhoi"; sStruct.rgptrssFixVal[0][2] = "hello"; sStruct.rgptrssFixVal[1][2] = "ohhello"; sStruct.rgptrssFixVal[0][3] = "hallo"; sStruct.rgptrssFixVal[1][3] = "ohhallo"; sStruct.rgptrssFixVal[0][4] = "servus"; sStruct.rgptrssFixVal[1][4] = "ohservus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgptr8Val[0].size(), 200); EXPECT_EQ(sStruct.rgptr8Val[1].size(), 300); for (size_t nIndex = 0; nIndex < sStruct.rgptr8Val[0].size() / 2; nIndex++) EXPECT_EQ(sStruct.rgptr8Val[0][nIndex], sStruct.rgptr8Val[0][nIndex + sStruct.rgptr8Val[0].size() / 2]); for (size_t nIndex = 0; nIndex < sStruct.rgptr8Val[1].size() / 3; nIndex++) EXPECT_EQ(sStruct.rgptr8Val[1][nIndex], sStruct.rgptr8Val[1][nIndex + sStruct.rgptr8Val[1].size() / 3]); EXPECT_EQ(sStruct.rgptrssVal[0].size(), 6); EXPECT_EQ(sStruct.rgptrssVal[1].size(), 9); for (size_t nIndex = 0; nIndex < sStruct.rgptrssVal[0].size() / 2; nIndex++) EXPECT_EQ(sStruct.rgptrssVal[0][nIndex], sStruct.rgptrssVal[0][nIndex + sStruct.rgptrssVal[0].size() / 2]); for (size_t nIndex = 0; nIndex < sStruct.rgptrssVal[1].size() / 3; nIndex++) EXPECT_EQ(sStruct.rgptrssVal[1][nIndex], sStruct.rgptrssVal[1][nIndex + sStruct.rgptrssVal[1].size() / 3]); EXPECT_EQ(sStruct.rgptr8FixVal[0].size(), 20); EXPECT_EQ(sStruct.rgptr8FixVal[1].size(), 20); for (size_t nIndex = 0; nIndex < sStruct.rgptr8FixVal[0].size(); nIndex++) EXPECT_EQ(sStruct.rgptr8FixVal[0][nIndex], static_cast(nIndex << 1)); for (size_t nIndex = 0; nIndex < sStruct.rgptr8FixVal[1].size(); nIndex++) EXPECT_EQ(sStruct.rgptr8FixVal[1][nIndex], static_cast(nIndex << 1)); EXPECT_EQ(sStruct.rgptrssFixVal[0].size(), 5); EXPECT_EQ(sStruct.rgptrssFixVal[1].size(), 5); EXPECT_EQ(sStruct.rgptrssFixVal[0][0], "hihi"); EXPECT_EQ(sStruct.rgptrssFixVal[1][0], "ohhiohhi"); EXPECT_EQ(sStruct.rgptrssFixVal[0][1], "hoihoi"); EXPECT_EQ(sStruct.rgptrssFixVal[1][1], "ohhoiohhoi"); EXPECT_EQ(sStruct.rgptrssFixVal[0][2], "hellohello"); EXPECT_EQ(sStruct.rgptrssFixVal[1][2], "ohhelloohhello"); EXPECT_EQ(sStruct.rgptrssFixVal[0][3], "hallohallo"); EXPECT_EQ(sStruct.rgptrssFixVal[1][3], "ohhalloohhallo"); EXPECT_EQ(sStruct.rgptrssFixVal[0][4], "servusservus"); EXPECT_EQ(sStruct.rgptrssFixVal[1][4], "ohservusohservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructSequenceArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgseq8Val[0].resize(100); sStruct.rgseq8Val[1].resize(100); for (size_t nIndex = 0; nIndex < sStruct.rgseq8Val[0].size(); nIndex++) sStruct.rgseq8Val[0][nIndex] = static_cast(nIndex); for (size_t nIndex = 0; nIndex < sStruct.rgseq8Val[1].size(); nIndex++) sStruct.rgseq8Val[1][nIndex] = static_cast(nIndex); sStruct.rgseqssVal[0].resize(3); sStruct.rgseqssVal[1].resize(3); sStruct.rgseqssVal[0][0] = "hello"; sStruct.rgseqssVal[1][0] = "ohhello"; sStruct.rgseqssVal[0][1] = "huhu"; sStruct.rgseqssVal[1][1] = "ohhuhu"; sStruct.rgseqssVal[0][2] = "hi"; sStruct.rgseqssVal[1][2] = "ohhi"; sStruct.rgseq8FixVal[0].resize(sStruct.rgseq8FixVal[0].capacity()); sStruct.rgseq8FixVal[1].resize(sStruct.rgseq8FixVal[1].capacity()); for (size_t nIndex = 0; nIndex < sStruct.rgseq8FixVal[0].size(); nIndex++) sStruct.rgseq8FixVal[0][nIndex] = static_cast(nIndex); for (size_t nIndex = 0; nIndex < sStruct.rgseq8FixVal[1].size(); nIndex++) sStruct.rgseq8FixVal[1][nIndex] = static_cast(nIndex); sStruct.rgseqssFixVal[0].resize(sStruct.seqssFixVal.capacity()); sStruct.rgseqssFixVal[1].resize(sStruct.seqssFixVal.capacity()); sStruct.rgseqssFixVal[0][0] = "hi"; sStruct.rgseqssFixVal[1][0] = "ohhi"; sStruct.rgseqssFixVal[0][1] = "hoi"; sStruct.rgseqssFixVal[1][1] = "ohhoi"; sStruct.rgseqssFixVal[0][2] = "hello"; sStruct.rgseqssFixVal[1][2] = "ohhello"; sStruct.rgseqssFixVal[0][3] = "hallo"; sStruct.rgseqssFixVal[1][3] = "ohhallo"; sStruct.rgseqssFixVal[0][4] = "servus"; sStruct.rgseqssFixVal[1][4] = "ohservus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgseq8Val[0].size(), 200); EXPECT_EQ(sStruct.rgseq8Val[1].size(), 300); for (size_t nIndex = 0; nIndex < sStruct.rgseq8Val[0].size() / 2; nIndex++) EXPECT_EQ(sStruct.rgseq8Val[0][nIndex], sStruct.rgseq8Val[0][nIndex + sStruct.rgseq8Val[0].size() / 2]); for (size_t nIndex = 0; nIndex < sStruct.rgseq8Val[1].size() / 3; nIndex++) EXPECT_EQ(sStruct.rgseq8Val[1][nIndex], sStruct.rgseq8Val[1][nIndex + sStruct.rgseq8Val[1].size() / 3]); EXPECT_EQ(sStruct.rgseqssVal[0].size(), 6); EXPECT_EQ(sStruct.rgseqssVal[1].size(), 9); for (size_t nIndex = 0; nIndex < sStruct.rgseqssVal[0].size() / 2; nIndex++) EXPECT_EQ(sStruct.rgseqssVal[0][nIndex], sStruct.rgseqssVal[0][nIndex + sStruct.rgseqssVal[0].size() / 2]); for (size_t nIndex = 0; nIndex < sStruct.rgseqssVal[1].size() / 3; nIndex++) EXPECT_EQ(sStruct.rgseqssVal[1][nIndex], sStruct.rgseqssVal[1][nIndex + sStruct.rgseqssVal[1].size() / 3]); EXPECT_EQ(sStruct.rgseq8FixVal[0].size(), 20); EXPECT_EQ(sStruct.rgseq8FixVal[1].size(), 20); for (size_t nIndex = 0; nIndex < sStruct.rgseq8FixVal[0].size(); nIndex++) EXPECT_EQ(sStruct.rgseq8FixVal[0][nIndex], static_cast(nIndex << 1)); for (size_t nIndex = 0; nIndex < sStruct.rgseq8FixVal[1].size(); nIndex++) EXPECT_EQ(sStruct.rgseq8FixVal[1][nIndex], static_cast(nIndex << 1)); EXPECT_EQ(sStruct.rgseqssFixVal[0].size(), 5); EXPECT_EQ(sStruct.rgseqssFixVal[1].size(), 5); EXPECT_EQ(sStruct.rgseqssFixVal[0][0], "hihi"); EXPECT_EQ(sStruct.rgseqssFixVal[1][0], "ohhiohhi"); EXPECT_EQ(sStruct.rgseqssFixVal[0][1], "hoihoi"); EXPECT_EQ(sStruct.rgseqssFixVal[1][1], "ohhoiohhoi"); EXPECT_EQ(sStruct.rgseqssFixVal[0][2], "hellohello"); EXPECT_EQ(sStruct.rgseqssFixVal[1][2], "ohhelloohhello"); EXPECT_EQ(sStruct.rgseqssFixVal[0][3], "hallohallo"); EXPECT_EQ(sStruct.rgseqssFixVal[1][3], "ohhalloohhallo"); EXPECT_EQ(sStruct.rgseqssFixVal[0][4], "servusservus"); EXPECT_EQ(sStruct.rgseqssFixVal[1][4], "ohservusohservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructInterfaceArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; //sStruct.rgidVal[0] = sdv::GetInterfaceId(); //sStruct.rgidVal[1] = sdv::GetInterfaceId(); //sStruct.rgifcVal[0] = static_cast(&sMultiply); //sStruct.rgifcVal[1] = static_cast(&sMultiply); //sStruct.rgpMultiplyValue[0] = &sMultiply; //sStruct.rgpMultiplyValue[1] = &sMultiply; //EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); //EXPECT_EQ(sStruct.rgidVal[0], sdv::GetInterfaceId()); //EXPECT_EQ(sStruct.rgidVal[1], sdv::GetInterfaceId()); //EXPECT_EQ(sStruct.rgifcVal[0].id(), sdv::GetInterfaceId()); //EXPECT_EQ(sStruct.rgifcVal[1].id(), sdv::GetInterfaceId()); //ASSERT_NE(sStruct.rgifcVal[0], nullptr); //ASSERT_NE(sStruct.rgifcVal[1], nullptr); //ASSERT_NE(sStruct.rgifcVal[0].get(), nullptr); //ASSERT_NE(sStruct.rgifcVal[1].get(), nullptr); //EXPECT_EQ(sStruct.rgifcVal[0].get()->Add(99), 19602); // 99 * 99 + 99 * 99 //EXPECT_EQ(sStruct.rgifcVal[1].get()->Add(99), 19602); // 99 * 99 + 99 * 99 //ASSERT_NE(sStruct.rgpMultiplyValue[0], nullptr); //ASSERT_NE(sStruct.rgpMultiplyValue[1], nullptr); //EXPECT_EQ(sStruct.rgpMultiplyValue[0]->Multiply(5), 625); // 5 * 5 * 5 * 5 //EXPECT_EQ(sStruct.rgpMultiplyValue[1]->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructSubCompoundArray) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.rgsSubVal[0].i = 1; sStruct.rgsSubVal[1].i = 2; // Incompatible serdes generation: BUG #398509 //sStruct.rgsIndVal[0].i = 10; //sStruct.rgsIndVal[1].i = 20; // Unnamed struct with array is not yet supported due to incorret serdes code generation: BUG #398246 //sStruct.rgsUnnamedVal[0].i = 100; //sStruct.rgsUnnamedVal[1].i = 200; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.rgsSubVal[0].i, 2); EXPECT_EQ(sStruct.rgsSubVal[1].i, 4); //EXPECT_EQ(sStruct.rgsIndVal[0].i, 20); //EXPECT_EQ(sStruct.rgsIndVal[1].i, 40); //EXPECT_EQ(sStruct.rgsUnnamedVal[0].i, 120); //EXPECT_EQ(sStruct.rgsUnnamedVal[1].i, 240); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructBooleanTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.tbVal = false; EXPECT_FALSE(sStruct.tbVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_TRUE(sStruct.tbVal); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructIntegralTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.tsVal = -10; sStruct.tusVal = 10; sStruct.tlVal = -20; sStruct.tulVal = 20; sStruct.tllVal = -30; sStruct.tullVal = 30; sStruct.ti8Val = -40; sStruct.tui8Val = 40; sStruct.ti16Val = -50; sStruct.tui16Val = 50; sStruct.ti32Val = -60; sStruct.tui32Val = 60; sStruct.ti64Val = -70; sStruct.tui64Val = 70; sStruct.tnVal = 80; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.tsVal, -11); EXPECT_EQ(sStruct.tusVal, 11u); EXPECT_EQ(sStruct.tlVal, -21); EXPECT_EQ(sStruct.tulVal, 21u); EXPECT_EQ(sStruct.tllVal, -31); EXPECT_EQ(sStruct.tullVal, 31u); EXPECT_EQ(static_cast(sStruct.ti8Val), static_cast(-41)); // Cast needed for ARM compatibility EXPECT_EQ(sStruct.tui8Val, 41u); EXPECT_EQ(sStruct.ti16Val, -51); EXPECT_EQ(sStruct.tui16Val, 51u); EXPECT_EQ(sStruct.ti32Val, -61); EXPECT_EQ(sStruct.tui32Val, 61u); EXPECT_EQ(sStruct.ti64Val, -71); EXPECT_EQ(sStruct.tui64Val, 71u); EXPECT_EQ(sStruct.tnVal, 81); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructCharacterTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.tcVal = 'A'; sStruct.tc16Val = u'D'; sStruct.tc32Val = U'G'; sStruct.twcVal = L'J'; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.tcVal, 'B'); EXPECT_EQ(sStruct.tc16Val, u'E'); EXPECT_EQ(sStruct.tc32Val, U'H'); EXPECT_EQ(sStruct.twcVal, L'K'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructFloatingPointTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; float fVal = -1234.5678f; sStruct.tfVal = fVal; double dVal = 8765.4321; sStruct.tdVal = dVal; long double ldVal = -1234.4321; sStruct.tldVal = ldVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.tfVal, fVal - 1000.000f); EXPECT_EQ(sStruct.tdVal, dVal + 1000.000); EXPECT_EQ(sStruct.tldVal, ldVal - 1000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructEnumTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.teHelloVal = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.teHelloVal, EHello::hallo); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructStringTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.tssVal = "hi"; sStruct.tss8Val = "huhu"; sStruct.tss16Val = u"hey"; sStruct.tss32Val = U"hello"; sStruct.twssVal = L"servus"; sStruct.tssFixVal = "hi"; sStruct.tss8FixVal = "huhu"; sStruct.tss16FixVal = u"hey"; sStruct.tss32FixVal = U"hello"; sStruct.twssFixVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.tssVal, "hij"); EXPECT_EQ(sStruct.tss8Val, "huhuv"); EXPECT_EQ(sStruct.tss16Val, u"heyz"); EXPECT_EQ(sStruct.tss32Val, U"hellop"); EXPECT_EQ(sStruct.twssVal, L"servust"); EXPECT_EQ(sStruct.tssFixVal, "hij"); EXPECT_EQ(sStruct.tss8FixVal, "huhuv"); EXPECT_EQ(sStruct.tss16FixVal, u"heyz"); EXPECT_EQ(sStruct.tss32FixVal, U"hellop"); EXPECT_EQ(sStruct.twssFixVal, L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Using typedefs of template based types produced an error: BUG #398266 TEST(IPC_Communication_Test, DISABLED_MarshallMegaStructPointerTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; //sStruct.tptr8Val.resize(100); //for (size_t nIndex = 0; nIndex < sStruct.tptr8Val.size(); nIndex++) // sStruct.tptr8Val[nIndex] = static_cast(nIndex); //sStruct.tptrssVal.resize(3); //sStruct.tptrssVal[0] = "hello"; //sStruct.tptrssVal[1] = "huhu"; //sStruct.tptrssVal[2] = "hi"; //sStruct.tptr8FixVal.resize(sStruct.tptr8FixVal.capacity()); //for (size_t nIndex = 0; nIndex < sStruct.tptr8FixVal.size(); nIndex++) // sStruct.tptr8FixVal[nIndex] = static_cast(nIndex); //sStruct.tptrssFixVal.resize(sStruct.tptrssFixVal.capacity()); //sStruct.tptrssFixVal[0] = "hi"; //sStruct.tptrssFixVal[1] = "hoi"; //sStruct.tptrssFixVal[2] = "hello"; //sStruct.tptrssFixVal[3] = "hallo"; //sStruct.tptrssFixVal[4] = "servus"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); //EXPECT_EQ(sStruct.tptr8Val.size(), 200); //for (size_t nIndex = 0; nIndex < sStruct.tptr8Val.size() / 2; nIndex++) // EXPECT_EQ(sStruct.tptr8Val[nIndex], sStruct.tptr8Val[nIndex + sStruct.tptr8Val.size() / 2]); //EXPECT_EQ(sStruct.tptrssVal.size(), 6); //for (size_t nIndex = 0; nIndex < sStruct.tptrssVal.size() / 2; nIndex++) // EXPECT_EQ(sStruct.tptrssVal[nIndex], sStruct.tptrssVal[nIndex + sStruct.tptrssVal.size() / 2]); //EXPECT_EQ(sStruct.tptr8FixVal.size(), 20); //for (size_t nIndex = 0; nIndex < sStruct.tptr8FixVal.size(); nIndex++) // EXPECT_EQ(sStruct.tptr8FixVal[nIndex], static_cast(nIndex << 1)); //EXPECT_EQ(sStruct.tptrssFixVal.size(), 5); //EXPECT_EQ(sStruct.tptrssFixVal[0], "hihi"); //EXPECT_EQ(sStruct.tptrssFixVal[1], "hoihoi"); //EXPECT_EQ(sStruct.tptrssFixVal[2], "hellohello"); //EXPECT_EQ(sStruct.tptrssFixVal[3], "hallohallo"); //EXPECT_EQ(sStruct.tptrssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Using typedefs of template based types produced an error: BUG #398266 TEST(IPC_Communication_Test, DISABLED_MarshallMegaStructSequenceTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; //sStruct.tseq8Val.resize(100); //for (size_t nIndex = 0; nIndex < sStruct.tseq8Val.size(); nIndex++) // sStruct.tseq8Val[nIndex] = static_cast(nIndex); //sStruct.tseqssVal.resize(3); //sStruct.tseqssVal[0] = "hello"; //sStruct.tseqssVal[1] = "huhu"; //sStruct.tseqssVal[2] = "hi"; //sStruct.tseq8FixVal.resize(sStruct.tseq8FixVal.capacity()); //for (size_t nIndex = 0; nIndex < sStruct.tseq8FixVal.size(); nIndex++) // sStruct.tseq8FixVal[nIndex] = static_cast(nIndex); //sStruct.tseqssFixVal.resize(sStruct.tseqssFixVal.capacity()); //sStruct.tseqssFixVal[0] = "hi"; //sStruct.tseqssFixVal[1] = "hoi"; //sStruct.tseqssFixVal[2] = "hello"; //sStruct.tseqssFixVal[3] = "hallo"; //sStruct.tseqssFixVal[4] = "servus"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); //EXPECT_EQ(sStruct.tseq8Val.size(), 200); //for (size_t nIndex = 0; nIndex < sStruct.tseq8Val.size() / 2; nIndex++) // EXPECT_EQ(sStruct.tseq8Val[nIndex], sStruct.tseq8Val[nIndex + sStruct.tseq8Val.size() / 2]); //EXPECT_EQ(sStruct.tseqssVal.size(), 6); //for (size_t nIndex = 0; nIndex < sStruct.tseqssVal.size() / 2; nIndex++) // EXPECT_EQ(sStruct.tseqssVal[nIndex], sStruct.tseqssVal[nIndex + sStruct.tseqssVal.size() / 2]); //EXPECT_EQ(sStruct.tseq8FixVal.size(), 20); //for (size_t nIndex = 0; nIndex < sStruct.tseq8FixVal.size(); nIndex++) // EXPECT_EQ(sStruct.tseq8FixVal[nIndex], static_cast(nIndex << 1)); //EXPECT_EQ(sStruct.tseqssFixVal.size(), 5); //EXPECT_EQ(sStruct.tseqssFixVal[0], "hihi"); //EXPECT_EQ(sStruct.tseqssFixVal[1], "hoihoi"); //EXPECT_EQ(sStruct.tseqssFixVal[2], "hellohello"); //EXPECT_EQ(sStruct.tseqssFixVal[3], "hallohallo"); //EXPECT_EQ(sStruct.tseqssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructInterfaceTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.tidVal = sdv::GetInterfaceId(); sStruct.tifcVal = static_cast(&sMultiply); // Typedef of interfaces current not possible. BUG #399464 //sStruct.ptMultiplyValue = &sMultiply; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.tidVal, sdv::GetInterfaceId()); EXPECT_EQ(sStruct.tifcVal.id(), sdv::GetInterfaceId()); ASSERT_NE(sStruct.tifcVal, nullptr); ASSERT_NE(sStruct.tifcVal.get(), nullptr); EXPECT_EQ(sStruct.tifcVal.get()->Add(99), 19602); // 99 * 99 + 99 * 99 // Typedef of interfaces current not possible. BUG #399464 //ASSERT_NE(sStruct.tpMultiplyValue, nullptr); //EXPECT_EQ(sStruct.tpMultiplyValue->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaStructSubCompoundTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaStruct sStruct{}; sStruct.tsSubVal.i = 1; sStruct.tsIndVal.i = 10; // Incompatible serdes generation: BUG #398509 //sStruct.tsUnnamedVal.i = 100; EXPECT_NO_THROW(pMegaTest->ProcessMegaStruct(sStruct)); EXPECT_EQ(sStruct.tsSubVal.i, 2); EXPECT_EQ(sStruct.tsIndVal.i, 20); // Incompatible serdes generation: BUG #398509 //EXPECT_EQ(sStruct.tsUnnamedVal.i, 120); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionBoolean) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(1); uUnion.bVal = false; EXPECT_FALSE(uUnion.bVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_TRUE(uUnion.bVal); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionIntegral) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(2); uUnion.sVal = -10; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.sVal, -11); uUnion.switch_to(3); uUnion.usVal = 10; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.usVal, 11u); uUnion.switch_to(4); uUnion.lVal = -20; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.lVal, -21); uUnion.switch_to(5); uUnion.ulVal = 20; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ulVal, 21u); uUnion.switch_to(6); uUnion.llVal = -30; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.llVal, -31); uUnion.switch_to(7); uUnion.ullVal = 30; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ullVal, 31u); uUnion.switch_to(8); uUnion.i8Val = -40; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(static_cast(uUnion.i8Val), static_cast(-41)); // Cast needed for ARM compatibility uUnion.switch_to(9); uUnion.ui8Val = 40; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ui8Val, 41u); uUnion.switch_to(10); uUnion.i16Val = -50; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.i16Val, -51); uUnion.switch_to(11); uUnion.ui16Val = 50; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ui16Val, 51u); uUnion.switch_to(12); uUnion.i32Val = -60; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.i32Val, -61); uUnion.switch_to(13); uUnion.ui32Val = 60; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ui32Val, 61u); uUnion.switch_to(14); uUnion.i64Val = -70; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.i64Val, -71); uUnion.switch_to(15); uUnion.ui64Val = 70; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ui64Val, 71u); uUnion.switch_to(23); uUnion.nVal = 80; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.nVal, 81); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionCharacter) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(16); uUnion.cVal = 'A'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.cVal, 'B'); uUnion.switch_to(17); uUnion.c16Val = u'D'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.c16Val, u'E'); uUnion.switch_to(18); uUnion.c32Val = U'G'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.c32Val, U'H'); uUnion.switch_to(19); uUnion.wcVal = L'J'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.wcVal, L'K'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionFloatingPoint) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(20); float fVal = -1234.5678f; uUnion.fVal = fVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.fVal, fVal - 1000.000f); uUnion.switch_to(21); double dVal = 8765.4321; uUnion.dVal = dVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.dVal, dVal + 1000.000); // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //uUnion.switch_to(22); //long double ldVal = -1234.4321; //uUnion.ldVal = ldVal; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.ldVal, ldVal - 1000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionEnum) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(24); uUnion.eHelloVal = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.eHelloVal, EHello::hallo); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionString) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(26); uUnion.ssVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ssVal, "hij"); uUnion.switch_to(27); uUnion.ss8Val = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ss8Val, "huhuv"); uUnion.switch_to(28); uUnion.ss16Val = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ss16Val, u"heyz"); uUnion.switch_to(29); uUnion.ss32Val = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ss32Val, U"hellop"); uUnion.switch_to(30); uUnion.wssVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.wssVal, L"servust"); uUnion.switch_to(31); uUnion.ssFixVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ssFixVal, "hij"); uUnion.switch_to(32); uUnion.ss8FixVal = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ss8FixVal, "huhuv"); uUnion.switch_to(33); uUnion.ss16FixVal = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ss16FixVal, u"heyz"); uUnion.switch_to(34); uUnion.ss32FixVal = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ss32FixVal, U"hellop"); uUnion.switch_to(35); uUnion.wssFixVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.wssFixVal, L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionPointer) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(36); uUnion.ptr8Val.resize(100); for (size_t nIndex = 0; nIndex < uUnion.ptr8Val.size(); nIndex++) uUnion.ptr8Val[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ptr8Val.size(), 200); for (size_t nIndex = 0; nIndex < uUnion.ptr8Val.size() / 2; nIndex++) EXPECT_EQ(uUnion.ptr8Val[nIndex], uUnion.ptr8Val[nIndex + uUnion.ptr8Val.size() / 2]); uUnion.switch_to(37); uUnion.ptrssVal.resize(3); uUnion.ptrssVal[0] = "hello"; uUnion.ptrssVal[1] = "huhu"; uUnion.ptrssVal[2] = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ptrssVal.size(), 6); for (size_t nIndex = 0; nIndex < uUnion.ptrssVal.size() / 2; nIndex++) EXPECT_EQ(uUnion.ptrssVal[nIndex], uUnion.ptrssVal[nIndex + uUnion.ptrssVal.size() / 2]); uUnion.switch_to(38); uUnion.ptr8FixVal.resize(uUnion.ptr8FixVal.capacity()); for (size_t nIndex = 0; nIndex < uUnion.ptr8FixVal.size(); nIndex++) uUnion.ptr8FixVal[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ptr8FixVal.size(), 20); for (size_t nIndex = 0; nIndex < uUnion.ptr8FixVal.size(); nIndex++) EXPECT_EQ(uUnion.ptr8FixVal[nIndex], static_cast(nIndex << 1)); uUnion.switch_to(39); uUnion.ptrssFixVal.resize(uUnion.ptrssFixVal.capacity()); uUnion.ptrssFixVal[0] = "hi"; uUnion.ptrssFixVal[1] = "hoi"; uUnion.ptrssFixVal[2] = "hello"; uUnion.ptrssFixVal[3] = "hallo"; uUnion.ptrssFixVal[4] = "servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ptrssFixVal.size(), 5); EXPECT_EQ(uUnion.ptrssFixVal[0], "hihi"); EXPECT_EQ(uUnion.ptrssFixVal[1], "hoihoi"); EXPECT_EQ(uUnion.ptrssFixVal[2], "hellohello"); EXPECT_EQ(uUnion.ptrssFixVal[3], "hallohallo"); EXPECT_EQ(uUnion.ptrssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionSequence) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(36); uUnion.seq8Val.resize(100); for (size_t nIndex = 0; nIndex < uUnion.seq8Val.size(); nIndex++) uUnion.seq8Val[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.seq8Val.size(), 200); for (size_t nIndex = 0; nIndex < uUnion.seq8Val.size() / 2; nIndex++) EXPECT_EQ(uUnion.seq8Val[nIndex], uUnion.seq8Val[nIndex + uUnion.seq8Val.size() / 2]); uUnion.switch_to(37); uUnion.seqssVal.resize(3); uUnion.seqssVal[0] = "hello"; uUnion.seqssVal[1] = "huhu"; uUnion.seqssVal[2] = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.seqssVal.size(), 6); for (size_t nIndex = 0; nIndex < uUnion.seqssVal.size() / 2; nIndex++) EXPECT_EQ(uUnion.seqssVal[nIndex], uUnion.seqssVal[nIndex + uUnion.seqssVal.size() / 2]); uUnion.switch_to(38); uUnion.seq8FixVal.resize(uUnion.seq8FixVal.capacity()); for (size_t nIndex = 0; nIndex < uUnion.seq8FixVal.size(); nIndex++) uUnion.seq8FixVal[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.seq8FixVal.size(), 20); for (size_t nIndex = 0; nIndex < uUnion.seq8FixVal.size(); nIndex++) EXPECT_EQ(uUnion.seq8FixVal[nIndex], static_cast(nIndex << 1)); uUnion.switch_to(39); uUnion.seqssFixVal.resize(uUnion.seqssFixVal.capacity()); uUnion.seqssFixVal[0] = "hi"; uUnion.seqssFixVal[1] = "hoi"; uUnion.seqssFixVal[2] = "hello"; uUnion.seqssFixVal[3] = "hallo"; uUnion.seqssFixVal[4] = "servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.seqssFixVal.size(), 5); EXPECT_EQ(uUnion.seqssFixVal[0], "hihi"); EXPECT_EQ(uUnion.seqssFixVal[1], "hoihoi"); EXPECT_EQ(uUnion.seqssFixVal[2], "hellohello"); EXPECT_EQ(uUnion.seqssFixVal[3], "hallohallo"); EXPECT_EQ(uUnion.seqssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionInterface) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(25); uUnion.idVal = sdv::GetInterfaceId(); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.idVal, sdv::GetInterfaceId()); uUnion.switch_to(44); uUnion.ifcVal = static_cast(&sMultiply); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ifcVal.id(), sdv::GetInterfaceId()); ASSERT_NE(uUnion.ifcVal, nullptr); ASSERT_NE(uUnion.ifcVal.get(), nullptr); EXPECT_EQ(uUnion.ifcVal.get()->Add(99), 19602); // 99 * 99 + 99 * 99 uUnion.switch_to(45); uUnion.pMultiplyValue = &sMultiply; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); ASSERT_NE(uUnion.pMultiplyValue, nullptr); EXPECT_EQ(uUnion.pMultiplyValue->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionSubCompound) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(46); uUnion.sSubVal.i = 1; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.sSubVal.i, 2); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionBooleanTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(201); uUnion.tbVal = false; EXPECT_FALSE(uUnion.tbVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_TRUE(uUnion.tbVal); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionIntegralTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(202); uUnion.tsVal = -10; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tsVal, -11); uUnion.switch_to(203); uUnion.tusVal = 10; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tusVal, 11u); uUnion.switch_to(204); uUnion.tlVal = -20; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tlVal, -21); uUnion.switch_to(205); uUnion.tulVal = 20; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tulVal, 21u); uUnion.switch_to(206); uUnion.tllVal = -30; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tllVal, -31); uUnion.switch_to(207); uUnion.tullVal = 30; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tullVal, 31u); uUnion.switch_to(208); uUnion.ti8Val = -40; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(static_cast(uUnion.ti8Val), static_cast(-41)); // Cast needed for ARM compatibility uUnion.switch_to(209); uUnion.tui8Val = 40; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tui8Val, 41u); uUnion.switch_to(210); uUnion.ti16Val = -50; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ti16Val, -51); uUnion.switch_to(211); uUnion.tui16Val = 50; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tui16Val, 51u); uUnion.switch_to(212); uUnion.ti32Val = -60; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ti32Val, -61); uUnion.switch_to(213); uUnion.tui32Val = 60; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tui32Val, 61u); uUnion.switch_to(214); uUnion.ti64Val = -70; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.ti64Val, -71); uUnion.switch_to(215); uUnion.tui64Val = 70; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tui64Val, 71u); uUnion.switch_to(223); uUnion.tnVal = 80; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tnVal, 81); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionCharacterTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(216); uUnion.tcVal = 'A'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tcVal, 'B'); uUnion.switch_to(217); uUnion.tc16Val = u'D'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tc16Val, u'E'); uUnion.switch_to(218); uUnion.tc32Val = U'G'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tc32Val, U'H'); uUnion.switch_to(219); uUnion.twcVal = L'J'; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.twcVal, L'K'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionFloatingPointTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(220); float fVal = -1234.5678f; uUnion.tfVal = fVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tfVal, fVal - 1000.000f); uUnion.switch_to(221); double dVal = 8765.4321; uUnion.tdVal = dVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tdVal, dVal + 1000.000); // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //uUnion.switch_to(222); //long double ldVal = -1234.4321; //uUnion.tldVal = ldVal; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tldVal, ldVal - 1000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionEnumTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(224); uUnion.teHelloVal = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.teHelloVal, EHello::hallo); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionStringTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(226); uUnion.tssVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tssVal, "hij"); uUnion.switch_to(227); uUnion.tss8Val = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tss8Val, "huhuv"); uUnion.switch_to(228); uUnion.tss16Val = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tss16Val, u"heyz"); uUnion.switch_to(229); uUnion.tss32Val = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tss32Val, U"hellop"); uUnion.switch_to(230); uUnion.twssVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.twssVal, L"servust"); uUnion.switch_to(231); uUnion.tssFixVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tssFixVal, "hij"); uUnion.switch_to(232); uUnion.tss8FixVal = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tss8FixVal, "huhuv"); uUnion.switch_to(233); uUnion.tss16FixVal = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tss16FixVal, u"heyz"); uUnion.switch_to(234); uUnion.tss32FixVal = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tss32FixVal, U"hellop"); uUnion.switch_to(235); uUnion.twssFixVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.twssFixVal, L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Using typedefs of template based types produced an error: BUG #398266 TEST(IPC_Communication_Test, DISABLED_MarshallMegaTypeBasedUnionPointerTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(236); //uUnion.tptr8Val.resize(100); //for (size_t nIndex = 0; nIndex < uUnion.tptr8Val.size(); nIndex++) // uUnion.tptr8Val[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tptr8Val.size(), 200); //for (size_t nIndex = 0; nIndex < uUnion.tptr8Val.size() / 2; nIndex++) // EXPECT_EQ(uUnion.tptr8Val[nIndex], uUnion.tptr8Val[nIndex + uUnion.tptr8Val.size() / 2]); //uUnion.switch_to(237); //uUnion.tptrssVal.resize(3); //uUnion.tptrssVal[0] = "hello"; //uUnion.tptrssVal[1] = "huhu"; //uUnion.tptrssVal[2] = "hi"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tptrssVal.size(), 6); //for (size_t nIndex = 0; nIndex < uUnion.tptrssVal.size() / 2; nIndex++) // EXPECT_EQ(uUnion.tptrssVal[nIndex], uUnion.tptrssVal[nIndex + uUnion.tptrssVal.size() / 2]); //uUnion.switch_to(238); //uUnion.tptr8FixVal.resize(uUnion.tptr8FixVal.capacity()); //for (size_t nIndex = 0; nIndex < uUnion.tptr8FixVal.size(); nIndex++) // uUnion.tptr8FixVal[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tptr8FixVal.size(), 20); //for (size_t nIndex = 0; nIndex < uUnion.tptr8FixVal.size(); nIndex++) // EXPECT_EQ(uUnion.tptr8FixVal[nIndex], static_cast(nIndex << 1)); //uUnion.switch_to(239); //uUnion.tptrssFixVal.resize(uUnion.tptrssFixVal.capacity()); //uUnion.tptrssFixVal[0] = "hi"; //uUnion.tptrssFixVal[1] = "hoi"; //uUnion.tptrssFixVal[2] = "hello"; //uUnion.tptrssFixVal[3] = "hallo"; //uUnion.tptrssFixVal[4] = "servus"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tptrssFixVal.size(), 5); //EXPECT_EQ(uUnion.tptrssFixVal[0], "hihi"); //EXPECT_EQ(uUnion.tptrssFixVal[1], "hoihoi"); //EXPECT_EQ(uUnion.tptrssFixVal[2], "hellohello"); //EXPECT_EQ(uUnion.tptrssFixVal[3], "hallohallo"); //EXPECT_EQ(uUnion.tptrssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Using typedefs of template based types produced an error: BUG #398266 TEST(IPC_Communication_Test, DISABLED_MarshallMegaTypeBasedUnionSequenceTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(236); //uUnion.tseq8Val.resize(100); //for (size_t nIndex = 0; nIndex < uUnion.tseq8Val.size(); nIndex++) // uUnion.tseq8Val[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tseq8Val.size(), 200); //for (size_t nIndex = 0; nIndex < uUnion.tseq8Val.size() / 2; nIndex++) // EXPECT_EQ(uUnion.tseq8Val[nIndex], uUnion.tseq8Val[nIndex + uUnion.tseq8Val.size() / 2]); //uUnion.switch_to(237); //uUnion.tseqssVal.resize(3); //uUnion.tseqssVal[0] = "hello"; //uUnion.tseqssVal[1] = "huhu"; //uUnion.tseqssVal[2] = "hi"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tseqssVal.size(), 6); //for (size_t nIndex = 0; nIndex < uUnion.tseqssVal.size() / 2; nIndex++) // EXPECT_EQ(uUnion.tseqssVal[nIndex], uUnion.tseqssVal[nIndex + uUnion.tseqssVal.size() / 2]); //uUnion.switch_to(238); //uUnion.tseq8FixVal.resize(uUnion.tseq8FixVal.capacity()); //for (size_t nIndex = 0; nIndex < uUnion.tseq8FixVal.size(); nIndex++) // uUnion.tseq8FixVal[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tseq8FixVal.size(), 20); //for (size_t nIndex = 0; nIndex < uUnion.tseq8FixVal.size(); nIndex++) // EXPECT_EQ(uUnion.tseq8FixVal[nIndex], static_cast(nIndex << 1)); //uUnion.switch_to(239); //uUnion.tseqssFixVal.resize(uUnion.tseqssFixVal.capacity()); //uUnion.tseqssFixVal[0] = "hi"; //uUnion.tseqssFixVal[1] = "hoi"; //uUnion.tseqssFixVal[2] = "hello"; //uUnion.tseqssFixVal[3] = "hallo"; //uUnion.tseqssFixVal[4] = "servus"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //EXPECT_EQ(uUnion.tseqssFixVal.size(), 5); //EXPECT_EQ(uUnion.tseqssFixVal[0], "hihi"); //EXPECT_EQ(uUnion.tseqssFixVal[1], "hoihoi"); //EXPECT_EQ(uUnion.tseqssFixVal[2], "hellohello"); //EXPECT_EQ(uUnion.tseqssFixVal[3], "hallohallo"); //EXPECT_EQ(uUnion.tseqssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionInterfaceTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(225); uUnion.tidVal = sdv::GetInterfaceId(); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tidVal, sdv::GetInterfaceId()); uUnion.switch_to(244); uUnion.tifcVal = static_cast(&sMultiply); EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tifcVal.id(), sdv::GetInterfaceId()); ASSERT_NE(uUnion.tifcVal, nullptr); ASSERT_NE(uUnion.tifcVal.get(), nullptr); EXPECT_EQ(uUnion.tifcVal.get()->Add(99), 19602); // 99 * 99 + 99 * 99 // Typedef of interfaces current not possible. BUG #399464 //uUnion.switch_to(245); //uUnion.tpMultiplyValue = &sMultiply; //EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); //ASSERT_NE(uUnion.tpMultiplyValue, nullptr); //EXPECT_EQ(uUnion.tpMultiplyValue->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaTypeBasedUnionSubCompoundTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); UMegaTypeBasedUnion uUnion; uUnion.switch_to(246); uUnion.tsSubVal.i = 1; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tsSubVal.i, 2); uUnion.switch_to(247); uUnion.tsIndVal.i = 10; EXPECT_NO_THROW(pMegaTest->ProcessMegaTypeBasedUnion(uUnion)); EXPECT_EQ(uUnion.tsIndVal.i, 20); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionBoolean) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(1); sUnion.uVal.bVal = false; EXPECT_FALSE(sUnion.uVal.bVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_TRUE(sUnion.uVal.bVal); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionIntegral) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(2); sUnion.uVal.sVal = -10; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.sVal, -11); sUnion.switch_to(3); sUnion.uVal.usVal = 10; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.usVal, 11u); sUnion.switch_to(4); sUnion.uVal.lVal = -20; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.lVal, -21); sUnion.switch_to(5); sUnion.uVal.ulVal = 20; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ulVal, 21u); sUnion.switch_to(6); sUnion.uVal.llVal = -30; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.llVal, -31); sUnion.switch_to(7); sUnion.uVal.ullVal = 30; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ullVal, 31u); sUnion.switch_to(8); sUnion.uVal.i8Val = -40; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(static_cast(sUnion.uVal.i8Val), static_cast(-41)); // Cast needed for ARM compatibility sUnion.switch_to(9); sUnion.uVal.ui8Val = 40; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ui8Val, 41u); sUnion.switch_to(10); sUnion.uVal.i16Val = -50; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.i16Val, -51); sUnion.switch_to(11); sUnion.uVal.ui16Val = 50; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ui16Val, 51u); sUnion.switch_to(12); sUnion.uVal.i32Val = -60; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.i32Val, -61); sUnion.switch_to(13); sUnion.uVal.ui32Val = 60; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ui32Val, 61u); sUnion.switch_to(14); sUnion.uVal.i64Val = -70; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.i64Val, -71); sUnion.switch_to(15); sUnion.uVal.ui64Val = 70; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ui64Val, 71u); sUnion.switch_to(23); sUnion.uVal.nVal = 80; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.nVal, 81); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionCharacter) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(16); sUnion.uVal.cVal = 'A'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.cVal, 'B'); sUnion.switch_to(17); sUnion.uVal.c16Val = u'D'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.c16Val, u'E'); sUnion.switch_to(18); sUnion.uVal.c32Val = U'G'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.c32Val, U'H'); sUnion.switch_to(19); sUnion.uVal.wcVal = L'J'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.wcVal, L'K'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionFloatingPoint) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(20); float fVal = -1234.5678f; sUnion.uVal.fVal = fVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.fVal, fVal - 1000.000f); sUnion.switch_to(21); double dVal = 8765.4321; sUnion.uVal.dVal = dVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.dVal, dVal + 1000.000); // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //sUnion.switch_to(22); //long double ldVal = -1234.4321; //sUnion.uVal.ldVal = ldVal; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.ldVal, ldVal - 1000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionEnum) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(24); sUnion.uVal.eHelloVal = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.eHelloVal, EHello::hallo); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionString) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(26); sUnion.uVal.ssVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ssVal, "hij"); sUnion.switch_to(27); sUnion.uVal.ss8Val = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ss8Val, "huhuv"); sUnion.switch_to(28); sUnion.uVal.ss16Val = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ss16Val, u"heyz"); sUnion.switch_to(29); sUnion.uVal.ss32Val = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ss32Val, U"hellop"); sUnion.switch_to(30); sUnion.uVal.wssVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.wssVal, L"servust"); sUnion.switch_to(31); sUnion.uVal.ssFixVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ssFixVal, "hij"); sUnion.switch_to(32); sUnion.uVal.ss8FixVal = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ss8FixVal, "huhuv"); sUnion.switch_to(33); sUnion.uVal.ss16FixVal = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ss16FixVal, u"heyz"); sUnion.switch_to(34); sUnion.uVal.ss32FixVal = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ss32FixVal, U"hellop"); sUnion.switch_to(35); sUnion.uVal.wssFixVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.wssFixVal, L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionPointer) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(36); sUnion.uVal.ptr8Val.resize(100); for (size_t nIndex = 0; nIndex < sUnion.uVal.ptr8Val.size(); nIndex++) sUnion.uVal.ptr8Val[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ptr8Val.size(), 200); for (size_t nIndex = 0; nIndex < sUnion.uVal.ptr8Val.size() / 2; nIndex++) EXPECT_EQ(sUnion.uVal.ptr8Val[nIndex], sUnion.uVal.ptr8Val[nIndex + sUnion.uVal.ptr8Val.size() / 2]); sUnion.switch_to(37); sUnion.uVal.ptrssVal.resize(3); sUnion.uVal.ptrssVal[0] = "hello"; sUnion.uVal.ptrssVal[1] = "huhu"; sUnion.uVal.ptrssVal[2] = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ptrssVal.size(), 6); for (size_t nIndex = 0; nIndex < sUnion.uVal.ptrssVal.size() / 2; nIndex++) EXPECT_EQ(sUnion.uVal.ptrssVal[nIndex], sUnion.uVal.ptrssVal[nIndex + sUnion.uVal.ptrssVal.size() / 2]); sUnion.switch_to(38); sUnion.uVal.ptr8FixVal.resize(sUnion.uVal.ptr8FixVal.capacity()); for (size_t nIndex = 0; nIndex < sUnion.uVal.ptr8FixVal.size(); nIndex++) sUnion.uVal.ptr8FixVal[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ptr8FixVal.size(), 20); for (size_t nIndex = 0; nIndex < sUnion.uVal.ptr8FixVal.size(); nIndex++) EXPECT_EQ(sUnion.uVal.ptr8FixVal[nIndex], static_cast(nIndex << 1)); sUnion.switch_to(39); sUnion.uVal.ptrssFixVal.resize(sUnion.uVal.ptrssFixVal.capacity()); sUnion.uVal.ptrssFixVal[0] = "hi"; sUnion.uVal.ptrssFixVal[1] = "hoi"; sUnion.uVal.ptrssFixVal[2] = "hello"; sUnion.uVal.ptrssFixVal[3] = "hallo"; sUnion.uVal.ptrssFixVal[4] = "servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ptrssFixVal.size(), 5); EXPECT_EQ(sUnion.uVal.ptrssFixVal[0], "hihi"); EXPECT_EQ(sUnion.uVal.ptrssFixVal[1], "hoihoi"); EXPECT_EQ(sUnion.uVal.ptrssFixVal[2], "hellohello"); EXPECT_EQ(sUnion.uVal.ptrssFixVal[3], "hallohallo"); EXPECT_EQ(sUnion.uVal.ptrssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionSequence) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(36); sUnion.uVal.seq8Val.resize(100); for (size_t nIndex = 0; nIndex < sUnion.uVal.seq8Val.size(); nIndex++) sUnion.uVal.seq8Val[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.seq8Val.size(), 200); for (size_t nIndex = 0; nIndex < sUnion.uVal.seq8Val.size() / 2; nIndex++) EXPECT_EQ(sUnion.uVal.seq8Val[nIndex], sUnion.uVal.seq8Val[nIndex + sUnion.uVal.seq8Val.size() / 2]); sUnion.switch_to(37); sUnion.uVal.seqssVal.resize(3); sUnion.uVal.seqssVal[0] = "hello"; sUnion.uVal.seqssVal[1] = "huhu"; sUnion.uVal.seqssVal[2] = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.seqssVal.size(), 6); for (size_t nIndex = 0; nIndex < sUnion.uVal.seqssVal.size() / 2; nIndex++) EXPECT_EQ(sUnion.uVal.seqssVal[nIndex], sUnion.uVal.seqssVal[nIndex + sUnion.uVal.seqssVal.size() / 2]); sUnion.switch_to(38); sUnion.uVal.seq8FixVal.resize(sUnion.uVal.seq8FixVal.capacity()); for (size_t nIndex = 0; nIndex < sUnion.uVal.seq8FixVal.size(); nIndex++) sUnion.uVal.seq8FixVal[nIndex] = static_cast(nIndex); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.seq8FixVal.size(), 20); for (size_t nIndex = 0; nIndex < sUnion.uVal.seq8FixVal.size(); nIndex++) EXPECT_EQ(sUnion.uVal.seq8FixVal[nIndex], static_cast(nIndex << 1)); sUnion.switch_to(39); sUnion.uVal.seqssFixVal.resize(sUnion.uVal.seqssFixVal.capacity()); sUnion.uVal.seqssFixVal[0] = "hi"; sUnion.uVal.seqssFixVal[1] = "hoi"; sUnion.uVal.seqssFixVal[2] = "hello"; sUnion.uVal.seqssFixVal[3] = "hallo"; sUnion.uVal.seqssFixVal[4] = "servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.seqssFixVal.size(), 5); EXPECT_EQ(sUnion.uVal.seqssFixVal[0], "hihi"); EXPECT_EQ(sUnion.uVal.seqssFixVal[1], "hoihoi"); EXPECT_EQ(sUnion.uVal.seqssFixVal[2], "hellohello"); EXPECT_EQ(sUnion.uVal.seqssFixVal[3], "hallohallo"); EXPECT_EQ(sUnion.uVal.seqssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionInterface) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(25); sUnion.uVal.idVal = sdv::GetInterfaceId(); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.idVal, sdv::GetInterfaceId()); sUnion.switch_to(44); sUnion.uVal.ifcVal = static_cast(&sMultiply); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ifcVal.id(), sdv::GetInterfaceId()); ASSERT_NE(sUnion.uVal.ifcVal, nullptr); ASSERT_NE(sUnion.uVal.ifcVal.get(), nullptr); EXPECT_EQ(sUnion.uVal.ifcVal.get()->Add(99), 19602); // 99 * 99 + 99 * 99 sUnion.switch_to(45); sUnion.uVal.pMultiplyValue = &sMultiply; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); ASSERT_NE(sUnion.uVal.pMultiplyValue, nullptr); EXPECT_EQ(sUnion.uVal.pMultiplyValue->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionSubCompound) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(46); sUnion.uVal.sSubVal.i = 1; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.sSubVal.i, 2); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionBooleanTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(201); sUnion.uVal.tbVal = false; EXPECT_FALSE(sUnion.uVal.tbVal); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_TRUE(sUnion.uVal.tbVal); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionIntegralTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(202); sUnion.uVal.tsVal = -10; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tsVal, -11); sUnion.switch_to(203); sUnion.uVal.tusVal = 10; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tusVal, 11u); sUnion.switch_to(204); sUnion.uVal.tlVal = -20; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tlVal, -21); sUnion.switch_to(205); sUnion.uVal.tulVal = 20; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tulVal, 21u); sUnion.switch_to(206); sUnion.uVal.tllVal = -30; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tllVal, -31); sUnion.switch_to(207); sUnion.uVal.tullVal = 30; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tullVal, 31u); sUnion.switch_to(208); sUnion.uVal.ti8Val = -40; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(static_cast(sUnion.uVal.ti8Val), static_cast(-41)); // Cast needed for ARM compatibility sUnion.switch_to(209); sUnion.uVal.tui8Val = 40; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tui8Val, 41u); sUnion.switch_to(210); sUnion.uVal.ti16Val = -50; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ti16Val, -51); sUnion.switch_to(211); sUnion.uVal.tui16Val = 50; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tui16Val, 51u); sUnion.switch_to(212); sUnion.uVal.ti32Val = -60; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ti32Val, -61); sUnion.switch_to(213); sUnion.uVal.tui32Val = 60; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tui32Val, 61u); sUnion.switch_to(214); sUnion.uVal.ti64Val = -70; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.ti64Val, -71); sUnion.switch_to(215); sUnion.uVal.tui64Val = 70; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tui64Val, 71u); sUnion.switch_to(223); sUnion.uVal.tnVal = 80; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tnVal, 81); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionCharacterTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(216); sUnion.uVal.tcVal = 'A'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tcVal, 'B'); sUnion.switch_to(217); sUnion.uVal.tc16Val = u'D'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tc16Val, u'E'); sUnion.switch_to(218); sUnion.uVal.tc32Val = U'G'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tc32Val, U'H'); sUnion.switch_to(219); sUnion.uVal.twcVal = L'J'; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.twcVal, L'K'); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionFloatingPointTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(220); float fVal = -1234.5678f; sUnion.uVal.tfVal = fVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tfVal, fVal - 1000.000f); sUnion.switch_to(221); double dVal = 8765.4321; sUnion.uVal.tdVal = dVal; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tdVal, dVal + 1000.000); // GCC issue with generated initialization in the consructor for the "long double" type: BUG #3982727 //sUnion.switch_to(222); //long double ldVal = -1234.4321; //sUnion.uVal.tldVal = ldVal; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tldVal, ldVal - 1000.000); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionEnumTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(224); sUnion.uVal.teHelloVal = EHello::hello; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.teHelloVal, EHello::hallo); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionStringTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(226); sUnion.uVal.tssVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tssVal, "hij"); sUnion.switch_to(227); sUnion.uVal.tss8Val = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tss8Val, "huhuv"); sUnion.switch_to(228); sUnion.uVal.tss16Val = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tss16Val, u"heyz"); sUnion.switch_to(229); sUnion.uVal.tss32Val = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tss32Val, U"hellop"); sUnion.switch_to(230); sUnion.uVal.twssVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.twssVal, L"servust"); sUnion.switch_to(231); sUnion.uVal.tssFixVal = "hi"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tssFixVal, "hij"); sUnion.switch_to(232); sUnion.uVal.tss8FixVal = "huhu"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tss8FixVal, "huhuv"); sUnion.switch_to(233); sUnion.uVal.tss16FixVal = u"hey"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tss16FixVal, u"heyz"); sUnion.switch_to(234); sUnion.uVal.tss32FixVal = U"hello"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tss32FixVal, U"hellop"); sUnion.switch_to(235); sUnion.uVal.twssFixVal = L"servus"; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.twssFixVal, L"servust"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Using typedefs of template based types produced an error: BUG #398266 TEST(IPC_Communication_Test, DISABLED_MarshallMegaVarBasedUnionPointerTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(236); //sUnion.uVal.tptr8Val.resize(100); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tptr8Val.size(); nIndex++) // sUnion.uVal.tptr8Val[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tptr8Val.size(), 200); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tptr8Val.size() / 2; nIndex++) // EXPECT_EQ(sUnion.uVal.tptr8Val[nIndex], sUnion.uVal.tptr8Val[nIndex + sUnion.uVal.tptr8Val.size() / 2]); //sUnion.switch_to(237); //sUnion.uVal.tptrssVal.resize(3); //sUnion.uVal.tptrssVal[0] = "hello"; //sUnion.uVal.tptrssVal[1] = "huhu"; //sUnion.uVal.tptrssVal[2] = "hi"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tptrssVal.size(), 6); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tptrssVal.size() / 2; nIndex++) // EXPECT_EQ(sUnion.uVal.tptrssVal[nIndex], sUnion.uVal.tptrssVal[nIndex + sUnion.uVal.tptrssVal.size() / 2]); //sUnion.switch_to(238); //sUnion.uVal.tptr8FixVal.resize(sUnion.uVal.tptr8FixVal.capacity()); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tptr8FixVal.size(); nIndex++) // sUnion.uVal.tptr8FixVal[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tptr8FixVal.size(), 20); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tptr8FixVal.size(); nIndex++) // EXPECT_EQ(sUnion.uVal.tptr8FixVal[nIndex], static_cast(nIndex << 1)); //sUnion.switch_to(239); //sUnion.uVal.tptrssFixVal.resize(sUnion.uVal.tptrssFixVal.capacity()); //sUnion.uVal.tptrssFixVal[0] = "hi"; //sUnion.uVal.tptrssFixVal[1] = "hoi"; //sUnion.uVal.tptrssFixVal[2] = "hello"; //sUnion.uVal.tptrssFixVal[3] = "hallo"; //sUnion.uVal.tptrssFixVal[4] = "servus"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tptrssFixVal.size(), 5); //EXPECT_EQ(sUnion.uVal.tptrssFixVal[0], "hihi"); //EXPECT_EQ(sUnion.uVal.tptrssFixVal[1], "hoihoi"); //EXPECT_EQ(sUnion.uVal.tptrssFixVal[2], "hellohello"); //EXPECT_EQ(sUnion.uVal.tptrssFixVal[3], "hallohallo"); //EXPECT_EQ(sUnion.uVal.tptrssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } // Using typedefs of template based types produced an error: BUG #398266 TEST(IPC_Communication_Test, DISABLED_MarshallMegaVarBasedUnionSequenceTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(236); //sUnion.uVal.tseq8Val.resize(100); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tseq8Val.size(); nIndex++) // sUnion.uVal.tseq8Val[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tseq8Val.size(), 200); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tseq8Val.size() / 2; nIndex++) // EXPECT_EQ(sUnion.uVal.tseq8Val[nIndex], sUnion.uVal.tseq8Val[nIndex + sUnion.uVal.tseq8Val.size() / 2]); //sUnion.switch_to(237); //sUnion.uVal.tseqssVal.resize(3); //sUnion.uVal.tseqssVal[0] = "hello"; //sUnion.uVal.tseqssVal[1] = "huhu"; //sUnion.uVal.tseqssVal[2] = "hi"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tseqssVal.size(), 6); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tseqssVal.size() / 2; nIndex++) // EXPECT_EQ(sUnion.uVal.tseqssVal[nIndex], sUnion.uVal.tseqssVal[nIndex + sUnion.uVal.tseqssVal.size() / 2]); //sUnion.switch_to(238); //sUnion.uVal.tseq8FixVal.resize(sUnion.uVal.tseq8FixVal.capacity()); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tseq8FixVal.size(); nIndex++) // sUnion.uVal.tseq8FixVal[nIndex] = static_cast(nIndex); //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tseq8FixVal.size(), 20); //for (size_t nIndex = 0; nIndex < sUnion.uVal.tseq8FixVal.size(); nIndex++) // EXPECT_EQ(sUnion.uVal.tseq8FixVal[nIndex], static_cast(nIndex << 1)); //sUnion.switch_to(239); //sUnion.uVal.tseqssFixVal.resize(sUnion.uVal.tseqssFixVal.capacity()); //sUnion.uVal.tseqssFixVal[0] = "hi"; //sUnion.uVal.tseqssFixVal[1] = "hoi"; //sUnion.uVal.tseqssFixVal[2] = "hello"; //sUnion.uVal.tseqssFixVal[3] = "hallo"; //sUnion.uVal.tseqssFixVal[4] = "servus"; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //EXPECT_EQ(sUnion.uVal.tseqssFixVal.size(), 5); //EXPECT_EQ(sUnion.uVal.tseqssFixVal[0], "hihi"); //EXPECT_EQ(sUnion.uVal.tseqssFixVal[1], "hoihoi"); //EXPECT_EQ(sUnion.uVal.tseqssFixVal[2], "hellohello"); //EXPECT_EQ(sUnion.uVal.tseqssFixVal[3], "hallohallo"); //EXPECT_EQ(sUnion.uVal.tseqssFixVal[4], "servusservus"); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionInterfaceTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); struct SMultiply : public IMultiplyValue { size_t Multiply(size_t n) { return n * n; } } sMultiply; ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(225); sUnion.uVal.tidVal = sdv::GetInterfaceId(); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tidVal, sdv::GetInterfaceId()); sUnion.switch_to(244); sUnion.uVal.tifcVal = static_cast(&sMultiply); EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tifcVal.id(), sdv::GetInterfaceId()); ASSERT_NE(sUnion.uVal.tifcVal, nullptr); ASSERT_NE(sUnion.uVal.tifcVal.get(), nullptr); EXPECT_EQ(sUnion.uVal.tifcVal.get()->Add(99), 19602); // 99 * 99 + 99 * 99 // Typedef of interfaces current not possible. BUG #399464 //sUnion.switch_to(245); //sUnion.uVal.tpMultiplyValue = &sMultiply; //EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); //ASSERT_NE(sUnion.uVal.tpMultiplyValue, nullptr); //EXPECT_EQ(sUnion.uVal.tpMultiplyValue->Multiply(5), 625); // 5 * 5 * 5 * 5 // Cleanup... control.Shutdown(); appcontrol.Shutdown(); } TEST(IPC_Communication_Test, MarshallMegaVarBasedUnionSubCompoundTypedef) { sdv::app::CAppControl appcontrol; ASSERT_TRUE(appcontrol.Startup(R"config( [Application] Mode = "Essential" [LogHandler] ViewFilter = "Fatal" )config")); ASSERT_TRUE(appcontrol.IsRunning()); // Start communication control CCommunicationControl control; control.Initialize(""); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::initialized); control.SetOperationMode(sdv::EOperationMode::configuring); EXPECT_EQ(control.GetObjectState(), sdv::EObjectState::configuring); // Load the shared memory components LoadIPCModules(control); // Create the server connection CInterfaceTest test; sdv::u8string ssConnectionString; EXPECT_TRUE(control.CreateServerConnection(sdv::com::EChannelType::local_channel, &test, 100, ssConnectionString) != 0u); // Create the client connection sdv::IInterfaceAccess* pObjectProxy = nullptr; EXPECT_TRUE(control.CreateClientConnection(ssConnectionString, 1000, pObjectProxy) != 0u); ASSERT_NE(pObjectProxy, nullptr); // Get the target interface IMegaTest* pMegaTest = pObjectProxy->GetInterface(); ASSERT_NE(pMegaTest, nullptr); SMegaVarBasedUnion sUnion; sUnion.switch_to(246); sUnion.uVal.tsSubVal.i = 1; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tsSubVal.i, 2); sUnion.switch_to(247); sUnion.uVal.tsIndVal.i = 10; EXPECT_NO_THROW(pMegaTest->ProcessMegaVarBasedUnion(sUnion)); EXPECT_EQ(sUnion.uVal.tsIndVal.i, 20); // Cleanup... control.Shutdown(); appcontrol.Shutdown(); }