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);
}
