TEST_F(DBusCommunicationTest, RemoteMethodCallSucceeds) { auto defaultTestProxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(domain_, serviceAddress_); ASSERT_TRUE((bool)defaultTestProxy); auto stub = std::make_shared<VERSION::commonapi::tests::TestInterfaceStubDefault>(); interface_ = stub->getStubAdapter()->getInterface(); bool serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); for(unsigned int i = 0; !serviceRegistered && i < 100; ++i) { serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); usleep(10000); } ASSERT_TRUE(serviceRegistered); for(unsigned int i = 0; !defaultTestProxy->isAvailable() && i < 100; ++i) { usleep(10000); } ASSERT_TRUE(defaultTestProxy->isAvailable()); uint32_t v1 = 5; std::string v2 = "Ciao ;)"; CommonAPI::CallStatus stat; defaultTestProxy->testVoidPredefinedTypeMethod(v1, v2, stat); EXPECT_EQ(stat, CommonAPI::CallStatus::SUCCESS); }
TEST_F(AddressTranslatorTest, ServicesUsingPredefinedAddressesCanCommunicate) { std::shared_ptr<CommonAPI::Runtime> runtime = CommonAPI::Runtime::get(); ASSERT_TRUE((bool)runtime); CommonAPI::Address commonApiAddress(commonApiAddresses[0]); auto defaultTestProxy = runtime->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(commonApiAddress.getDomain(), commonApiAddress.getInstance()); ASSERT_TRUE((bool)defaultTestProxy); auto stub = std::make_shared<VERSION::commonapi::tests::TestInterfaceStubDefault>(); bool serviceNameAcquired = runtime->registerService(commonApiAddress.getDomain(), commonApiAddress.getInstance(), stub, "connection"); for(unsigned int i = 0; !serviceNameAcquired && i < 100; i++) { serviceNameAcquired = runtime->registerService(commonApiAddress.getDomain(), commonApiAddress.getInstance(), stub, "connection"); usleep(10000); } ASSERT_TRUE(serviceNameAcquired); for(unsigned int i = 0; !defaultTestProxy->isAvailable() && i < 100; ++i) { usleep(10000); } ASSERT_TRUE(defaultTestProxy->isAvailable()); uint32_t v1 = 5; std::string v2 = "Hai :)"; CommonAPI::CallStatus stat; defaultTestProxy->testVoidPredefinedTypeMethod(v1, v2, stat); ASSERT_EQ(stat, CommonAPI::CallStatus::SUCCESS); runtime->unregisterService(commonApiAddress.getDomain(), stub->getStubAdapter()->getInterface(), commonApiAddress.getInstance()); }
// Multiple proxies in separate threads, one stub TEST_F(DBusLoadTest, MultipleClientsSingleStubCallsSucceed) { std::array<std::shared_ptr<CommonAPI::Factory>, numProxies_> testProxyFactories; std::array<std::shared_ptr<VERSION::commonapi::tests::TestInterfaceProxyBase>, numProxies_> testProxies; for (unsigned int i = 0; i < numProxies_; i++) { testProxies[i] = runtime_->buildProxy < VERSION::commonapi::tests::TestInterfaceProxy >(domain_, serviceAddress_); ASSERT_TRUE((bool )testProxies[i]); } auto stub = std::make_shared<TestInterfaceStubFinal>(); bool serviceRegistered = false; for (auto i = 0; !serviceRegistered && i < 100; ++i) { serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); if(!serviceRegistered) std::this_thread::sleep_for(std::chrono::microseconds(10000)); } ASSERT_TRUE(serviceRegistered); bool allProxiesAvailable = false; for (unsigned int i = 0; !allProxiesAvailable && i < 100; ++i) { allProxiesAvailable = true; for (unsigned int j = 0; j < numProxies_; ++j) { allProxiesAvailable = allProxiesAvailable && testProxies[j]->isAvailable(); } if (!allProxiesAvailable) std::this_thread::sleep_for(std::chrono::microseconds(10000)); } ASSERT_TRUE(allProxiesAvailable); uint32_t callId = 0; for (unsigned int i = 0; i < numCallsPerProxy_; i++) { for (unsigned int j = 0; j < numProxies_; j++) { uint32_t in1 = i; std::string in2 = "string" + std::to_string(i) + "_" + std::to_string(j); testProxies[j]->testPredefinedTypeMethodAsync( in1, in2, std::bind( &DBusLoadTest::TestPredefinedTypeMethodAsyncCallback, this, callId++, in1, in2, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); } } bool allCallsSucceeded = false; for (unsigned int i = 0; !allCallsSucceeded && i < 100; ++i) { allCallsSucceeded = std::all_of(callSucceeded_.cbegin(), callSucceeded_.cend(), [](int b){ return b; }); if (!allCallsSucceeded) std::this_thread::sleep_for(std::chrono::microseconds(100000)); } ASSERT_TRUE(allCallsSucceeded); runtime_->unregisterService(domain_, stub->getStubAdapter()->getInterface(), serviceAddress_); }
TEST_F(DBusCommunicationTest, SameStubCanBeRegisteredSeveralTimes) { auto defaultTestProxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(domain_, serviceAddress_); auto defaultTestProxy2 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(domain_, serviceAddress2_); auto defaultTestProxy3 = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(domain_, serviceAddress3_); ASSERT_TRUE((bool)defaultTestProxy); ASSERT_TRUE((bool)defaultTestProxy2); ASSERT_TRUE((bool)defaultTestProxy3); auto stub = std::make_shared<VERSION::commonapi::tests::TestInterfaceStubDefault>(); interface_ = stub->getStubAdapter()->getInterface(); bool serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); bool serviceRegistered2 = runtime_->registerService(domain_, serviceAddress2_, stub, "connection"); bool serviceRegistered3 = runtime_->registerService(domain_, serviceAddress3_, stub, "connection"); for (unsigned int i = 0; (!serviceRegistered || !serviceRegistered2 || !serviceRegistered3) && i < 100; ++i) { if (!serviceRegistered) { serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); } if (!serviceRegistered2) { serviceRegistered2 = runtime_->registerService(domain_, serviceAddress2_, stub, "connection"); } if (!serviceRegistered3) { serviceRegistered3 = runtime_->registerService(domain_, serviceAddress3_, stub, "connection"); } usleep(10000); } ASSERT_TRUE(serviceRegistered); ASSERT_TRUE(serviceRegistered2); ASSERT_TRUE(serviceRegistered3); for(unsigned int i = 0; (!defaultTestProxy->isAvailable() || !defaultTestProxy2->isAvailable() || !defaultTestProxy3->isAvailable()) && i < 100; ++i) { usleep(10000); } ASSERT_TRUE(defaultTestProxy->isAvailable()); ASSERT_TRUE(defaultTestProxy2->isAvailable()); ASSERT_TRUE(defaultTestProxy3->isAvailable()); uint32_t v1 = 5; std::string v2 = "Ciao ;)"; CommonAPI::CallStatus stat, stat2, stat3; defaultTestProxy->testVoidPredefinedTypeMethod(v1, v2, stat); defaultTestProxy2->testVoidPredefinedTypeMethod(v1, v2, stat2); defaultTestProxy3->testVoidPredefinedTypeMethod(v1, v2, stat3); EXPECT_EQ(stat, CommonAPI::CallStatus::SUCCESS); EXPECT_EQ(stat2, CommonAPI::CallStatus::SUCCESS); EXPECT_EQ(stat3, CommonAPI::CallStatus::SUCCESS); }
TEST_F(DBusCommunicationTest, AccessStubAdapterBeforeInitialised) { auto stub = std::make_shared<VERSION::commonapi::tests::TestInterfaceStubDefault>(); interface_ = stub->getStubAdapter()->getInterface(); unsigned int in = 5; stub->setTestPredefinedTypeAttributeAttribute(in); bool serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); for (unsigned int i = 0; !serviceRegistered && i < 100; i++) { if (!serviceRegistered) { serviceRegistered = runtime_->registerService(domain_, serviceAddress_, stub, "connection"); } usleep(10000); } ASSERT_TRUE(serviceRegistered); }
TEST_F(DBusCommunicationTest, MixedSyncAndAsyncCallsSucceed) { auto defaultTestProxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(domain_, serviceAddress5_); ASSERT_TRUE((bool)defaultTestProxy); auto stub = std::make_shared<VERSION::commonapi::tests::TestInterfaceStubDefault>(); interface_ = stub->getStubAdapter()->getInterface(); bool serviceRegistered = runtime_->registerService(domain_, serviceAddress5_, stub, "connection"); for(unsigned int i = 0; !serviceRegistered && i < 100; ++i) { serviceRegistered = runtime_->registerService(domain_, serviceAddress5_, stub, "connection"); usleep(10000); } ASSERT_TRUE(serviceRegistered); for (unsigned int i = 0; !defaultTestProxy->isAvailable() && i < 100; ++i) { usleep(10000); } ASSERT_TRUE(defaultTestProxy->isAvailable()); uint32_t v1 = 5; std::string v2 = "Hai :)"; CommonAPI::CallStatus stat; unsigned int responseCounter = 0; for (unsigned int i = 0; i < 10; i++) { defaultTestProxy->testVoidPredefinedTypeMethodAsync(v1, v2, [&responseCounter](const CommonAPI::CallStatus& status) { if(status == CommonAPI::CallStatus::SUCCESS) { responseCounter++; } } ); defaultTestProxy->testVoidPredefinedTypeMethod(v1, v2, stat); EXPECT_EQ(stat, CommonAPI::CallStatus::SUCCESS); } for (unsigned int i = 0; i < 500 && responseCounter < 10; i++) { usleep(1000); } EXPECT_EQ(10, responseCounter); }
TEST_F(DBusCommunicationTest, ProxyCanFetchVersionAttributeFromStub) { auto defaultTestProxy = runtime_->buildProxy<VERSION::commonapi::tests::TestInterfaceProxy>(domain_, serviceAddress4_); ASSERT_TRUE((bool)defaultTestProxy); auto stub = std::make_shared<VERSION::commonapi::tests::TestInterfaceStubDefault>(); interface_ = stub->getStubAdapter()->getInterface(); bool serviceRegistered = runtime_->registerService(domain_, serviceAddress4_, stub, "connection"); ASSERT_TRUE(serviceRegistered); for (unsigned int i = 0; !defaultTestProxy->isAvailable() && i < 100; ++i) { usleep(10000); } ASSERT_TRUE(defaultTestProxy->isAvailable()); CommonAPI::InterfaceVersionAttribute& versionAttribute = defaultTestProxy->getInterfaceVersionAttribute(); CommonAPI::Version version; CommonAPI::CallStatus status; versionAttribute.getValue(status, version); ASSERT_EQ(CommonAPI::CallStatus::SUCCESS, status); ASSERT_TRUE(version.Major > 0 || version.Minor > 0); }