test/simulation/rpc_test.cc - platform/system/chre - Git at Google

 /*
  * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "rpc_test.h"

 #include <cstdint>

 #include "chre/core/event_loop.h"
 #include "chre/core/event_loop_manager.h"
 #include "chre/core/settings.h"
 #include "chre/util/nanoapp/log.h"
 #include "chre/util/time.h"
 #include "chre_api/chre/event.h"
 #include "chre_api/chre/re.h"

 #include "gtest/gtest.h"
 #include "inc/test_util.h"
 #include "test_base.h"
 #include "test_event.h"
 #include "test_event_queue.h"
 #include "test_util.h"

 namespace chre {

 pw::Status RpcTestService::Increment(const chre_rpc_NumberMessage &request,
                                      chre_rpc_NumberMessage &response) {
   EnvSingleton::get()->mServer.setPermissionForNextMessage(
       CHRE_MESSAGE_PERMISSION_NONE);
   response.number = request.number + 1;
   return pw::OkStatus();
 }

 namespace {

 TEST_F(TestBase, PwRpcCanPublishServicesInNanoappStart) {
   class App : public TestNanoapp {
    public:
     bool start() override {
       struct chreNanoappRpcService servicesA[] = {
           {.id = 1, .version = 0},
           {.id = 2, .version = 0},
       };

       struct chreNanoappRpcService servicesB[] = {
           {.id = 3, .version = 0},
           {.id = 4, .version = 0},
       };

       return chrePublishRpcServices(servicesA, 2 /* numServices */) &&
              chrePublishRpcServices(servicesB, 2 /* numServices */);
     }
   };

   uint64_t appId = loadNanoapp(MakeUnique<App>());
   Nanoapp *napp = getNanoappByAppId(appId);
   ASSERT_NE(napp, nullptr);

   EXPECT_EQ(napp->getRpcServices().size(), 4);
   EXPECT_EQ(napp->getRpcServices()[0].id, 1);
   EXPECT_EQ(napp->getRpcServices()[1].id, 2);
   EXPECT_EQ(napp->getRpcServices()[2].id, 3);
   EXPECT_EQ(napp->getRpcServices()[3].id, 4);
 }

 TEST_F(TestBase, PwRpcCanNotPublishDuplicateServices) {
   class App : public TestNanoapp {
     bool start() override {
       struct chreNanoappRpcService servicesA[] = {
           {.id = 1, .version = 0},
           {.id = 2, .version = 0},
       };

       bool success = chrePublishRpcServices(servicesA, 2 /* numServices */);

       EXPECT_FALSE(chrePublishRpcServices(servicesA, 2 /* numServices */));

       struct chreNanoappRpcService servicesB[] = {
           {.id = 5, .version = 0},
           {.id = 5, .version = 0},
       };

       EXPECT_FALSE(chrePublishRpcServices(servicesB, 2 /* numServices */));

       return success;
     }
   };

   uint64_t appId = loadNanoapp(MakeUnique<App>());
   Nanoapp *napp = getNanoappByAppId(appId);
   ASSERT_NE(napp, nullptr);

   EXPECT_EQ(napp->getRpcServices().size(), 2);
   EXPECT_EQ(napp->getRpcServices()[0].id, 1);
   EXPECT_EQ(napp->getRpcServices()[1].id, 2);
 }

 TEST_F(TestBase, PwRpcDifferentAppCanPublishSameServices) {
   class App : public TestNanoapp {
    public:
     explicit App(uint64_t id) : TestNanoapp(TestNanoappInfo{.id = id}) {}

     bool start() override {
       struct chreNanoappRpcService services[] = {
           {.id = 1, .version = 0},
           {.id = 2, .version = 0},
       };

       return chrePublishRpcServices(services, 2 /* numServices */);
     }
   };

   uint64_t app1Id = loadNanoapp(MakeUnique<App>(0x01));
   uint64_t app2Id = loadNanoapp(MakeUnique<App>(0x02));
   Nanoapp *napp1 = getNanoappByAppId(app1Id);
   ASSERT_NE(napp1, nullptr);

   EXPECT_EQ(napp1->getRpcServices().size(), 2);
   EXPECT_EQ(napp1->getRpcServices()[0].id, 1);
   EXPECT_EQ(napp1->getRpcServices()[1].id, 2);

   Nanoapp *napp2 = getNanoappByAppId(app2Id);
   ASSERT_NE(napp2, nullptr);

   EXPECT_EQ(napp2->getRpcServices().size(), 2);
   EXPECT_EQ(napp2->getRpcServices()[0].id, 1);
   EXPECT_EQ(napp2->getRpcServices()[1].id, 2);
 }

 TEST_F(TestBase, PwRpcCanNotPublishServicesOutsideOfNanoappStart) {
   CREATE_CHRE_TEST_EVENT(PUBLISH_SERVICES, 0);

   class App : public TestNanoapp {
    public:
     void handleEvent(uint32_t, uint16_t eventType,
                      const void *eventData) override {
       switch (eventType) {
         case CHRE_EVENT_TEST_EVENT: {
           auto event = static_cast<const TestEvent *>(eventData);
           switch (event->type) {
             case PUBLISH_SERVICES: {
               struct chreNanoappRpcService services[] = {
                   {.id = 1, .version = 0},
                   {.id = 2, .version = 0},
               };

               bool success =
                   chrePublishRpcServices(services, 2 /* numServices */);
               TestEventQueueSingleton::get()->pushEvent(PUBLISH_SERVICES,
                                                         success);
               break;
             }
           }
         }
       }
     }
   };

   uint64_t appId = loadNanoapp(MakeUnique<App>());

   bool success = true;
   sendEventToNanoapp(appId, PUBLISH_SERVICES);
   waitForEvent(PUBLISH_SERVICES, &success);
   EXPECT_FALSE(success);

   Nanoapp *napp = getNanoappByAppId(appId);
   ASSERT_NE(napp, nullptr);

   EXPECT_EQ(napp->getRpcServices().size(), 0);
 }

 TEST_F(TestBase, PwRpcRegisterServicesShouldGracefullyFailOnDuplicatedService) {
   class App : public TestNanoapp {
    public:
     bool start() override {
       static RpcTestService testService;

       chre::RpcServer::Service service = {.service = testService,
                                           .id = 0xca8f7150a3f05847,
                                           .version = 0x01020034};

       chre::RpcServer &server = EnvSingleton::get()->mServer;

       bool status = server.registerServices(1, &service);

       EXPECT_TRUE(status);

       EXPECT_FALSE(server.registerServices(1, &service));

       return status;
     }

     void end() override {
       EnvSingleton::get()->closeServer();
     }
   };

   EnvSingleton::init();
   uint64_t appId = loadNanoapp(MakeUnique<App>());
   unloadNanoapp(appId);
   EnvSingleton::deinit();
 }

 TEST_F(TestBase, PwRpcGetNanoappInfoByAppIdReturnsServices) {
   CREATE_CHRE_TEST_EVENT(QUERY_INFO, 0);

   class App : public TestNanoapp {
    public:
     bool start() override {
       struct chreNanoappRpcService services[] = {
           {.id = 1, .version = 2},
           {.id = 2, .version = 3},
       };

       return chrePublishRpcServices(services, 2 /* numServices */);
     }

     void handleEvent(uint32_t, uint16_t eventType,
                      const void *eventData) override {
       switch (eventType) {
         case CHRE_EVENT_TEST_EVENT: {
           auto event = static_cast<const TestEvent *>(eventData);
           switch (event->type) {
             case QUERY_INFO: {
               auto id = static_cast<uint64_t *>(event->data);
               bool success = chreGetNanoappInfoByAppId(*id, &mInfo);
               const struct chreNanoappInfo *pInfo = success ? &mInfo : nullptr;
               TestEventQueueSingleton::get()->pushEvent(QUERY_INFO, pInfo);
               break;
             }
           }
         }
       }
     }

    protected:
     struct chreNanoappInfo mInfo;
   };

   uint64_t appId = loadNanoapp(MakeUnique<App>());

   struct chreNanoappInfo *pInfo = nullptr;
   sendEventToNanoapp(appId, QUERY_INFO, appId);
   waitForEvent(QUERY_INFO, &pInfo);
   EXPECT_TRUE(pInfo != nullptr);
   EXPECT_EQ(pInfo->rpcServiceCount, 2);
   EXPECT_EQ(pInfo->rpcServices[0].id, 1);
   EXPECT_EQ(pInfo->rpcServices[0].version, 2);
   EXPECT_EQ(pInfo->rpcServices[1].id, 2);
   EXPECT_EQ(pInfo->rpcServices[1].version, 3);
   EXPECT_EQ(pInfo->reserved[0], 0);
   EXPECT_EQ(pInfo->reserved[1], 0);
   EXPECT_EQ(pInfo->reserved[2], 0);
 }

 TEST_F(TestBase, PwRpcClientNanoappCanRequestServerNanoapp) {
   CREATE_CHRE_TEST_EVENT(INCREMENT_REQUEST, 0);

   class ClientApp : public TestNanoapp {
    public:
     ClientApp() : TestNanoapp(TestNanoappInfo{.id = kPwRcpClientAppId}) {}

     void handleEvent(uint32_t senderInstanceId, uint16_t eventType,
                      const void *eventData) override {
       Env *env = EnvSingleton::get();

       env->mClient.handleEvent(senderInstanceId, eventType, eventData);
       switch (eventType) {
         case CHRE_EVENT_TEST_EVENT: {
           auto event = static_cast<const TestEvent *>(eventData);
           switch (event->type) {
             case INCREMENT_REQUEST: {
               auto client =
                   env->mClient
                       .get<rpc::pw_rpc::nanopb::RpcTestService::Client>();
               if (client.has_value()) {
                 chre_rpc_NumberMessage incrementRequest;
                 incrementRequest.number = *static_cast<uint32_t *>(event->data);
                 env->mIncrementCall = client->Increment(
                     incrementRequest, [](const chre_rpc_NumberMessage &response,
                                          pw::Status status) {
                       if (status.ok()) {
                         EnvSingleton::get()->mNumber = response.number;
                         TestEventQueueSingleton::get()->pushEvent(
                             INCREMENT_REQUEST, true);
                       } else {
                         TestEventQueueSingleton::get()->pushEvent(
                             INCREMENT_REQUEST, false);
                       }
                     });
               } else {
                 TestEventQueueSingleton::get()->pushEvent(INCREMENT_REQUEST,
                                                           false);
               }
             }
           }
         }
       }
     }

     void end() {
       EnvSingleton::get()->closeClient();
     }
   };

   class ServerApp : public TestNanoapp {
    public:
     ServerApp() : TestNanoapp(TestNanoappInfo{.id = kPwRcpServerAppId}) {}

     bool start() override {
       chre::RpcServer::Service service = {
           .service = EnvSingleton::get()->mRpcTestService,
           .id = 0xca8f7150a3f05847,
           .version = 0x01020034};
       return EnvSingleton::get()->mServer.registerServices(1, &service);
     }

     void handleEvent(uint32_t senderInstanceId, uint16_t eventType,
                      const void *eventData) override {
       EnvSingleton::get()->mServer.handleEvent(senderInstanceId, eventType,
                                                eventData);
     }

     void end() {
       EnvSingleton::get()->closeServer();
     }
   };

   EnvSingleton::init();
   uint64_t serverId = loadNanoapp(MakeUnique<ServerApp>());
   uint64_t clientId = loadNanoapp(MakeUnique<ClientApp>());
   bool status;
   constexpr uint32_t kNumber = 101;

   sendEventToNanoapp(clientId, INCREMENT_REQUEST, kNumber);
   waitForEvent(INCREMENT_REQUEST, &status);
   EXPECT_TRUE(status);
   EXPECT_EQ(EnvSingleton::get()->mNumber, kNumber + 1);
   unloadNanoapp(serverId);
   unloadNanoapp(clientId);
   EnvSingleton::deinit();
 }

 TEST_F(TestBase, PwRpcRpcClientHasServiceCheckForAMatchingService) {
   CREATE_CHRE_TEST_EVENT(QUERY_HAS_SERVICE, 0);

   struct ServiceInfo {
     uint64_t id;
     uint32_t version;
     uint64_t appId;
   };

   class App : public TestNanoapp {
    public:
     bool start() override {
       struct chreNanoappRpcService services[] = {{.id = 1, .version = 2}};

       return chrePublishRpcServices(services, 1 /* numServices */);
     }

     void handleEvent(uint32_t, uint16_t eventType, const void *eventData) {
       switch (eventType) {
         case CHRE_EVENT_TEST_EVENT: {
           auto event = static_cast<const TestEvent *>(eventData);
           switch (event->type) {
             case QUERY_HAS_SERVICE: {
               auto service =
                   static_cast<const struct ServiceInfo *>(event->data);
               RpcClient client{service->appId};
               bool hasService =
                   client.hasService(service->id, service->version);
               TestEventQueueSingleton::get()->pushEvent(QUERY_HAS_SERVICE,
                                                         hasService);
               break;
             }
           }
           break;
         }
       }
     }
   };

   uint64_t appId = loadNanoapp(MakeUnique<App>());

   ServiceInfo service;
   bool hasService = false;

   service = {.id = 1, .version = 2, .appId = appId};
   sendEventToNanoapp(appId, QUERY_HAS_SERVICE, service);
   waitForEvent(QUERY_HAS_SERVICE, &hasService);
   EXPECT_TRUE(hasService);
   service = {.id = 10, .version = 2, .appId = appId};
   sendEventToNanoapp(appId, QUERY_HAS_SERVICE, service);
   waitForEvent(QUERY_HAS_SERVICE, &hasService);
   EXPECT_FALSE(hasService);
 }

 }  // namespace

 }  // namespace chre
	/*
	* Copyright (C) 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "rpc_test.h"

	#include <cstdint>

	#include "chre/core/event_loop.h"
	#include "chre/core/event_loop_manager.h"
	#include "chre/core/settings.h"
	#include "chre/util/nanoapp/log.h"
	#include "chre/util/time.h"
	#include "chre_api/chre/event.h"
	#include "chre_api/chre/re.h"

	#include "gtest/gtest.h"
	#include "inc/test_util.h"
	#include "test_base.h"
	#include "test_event.h"
	#include "test_event_queue.h"
	#include "test_util.h"

	namespace chre {

	pw::Status RpcTestService::Increment(const chre_rpc_NumberMessage &request,
	chre_rpc_NumberMessage &response) {
	EnvSingleton::get()->mServer.setPermissionForNextMessage(
	CHRE_MESSAGE_PERMISSION_NONE);
	response.number = request.number + 1;
	return pw::OkStatus();
	}

	namespace {

	TEST_F(TestBase, PwRpcCanPublishServicesInNanoappStart) {
	class App : public TestNanoapp {
	public:
	bool start() override {
	struct chreNanoappRpcService servicesA[] = {
	{.id = 1, .version = 0},
	{.id = 2, .version = 0},
	};

	struct chreNanoappRpcService servicesB[] = {
	{.id = 3, .version = 0},
	{.id = 4, .version = 0},
	};

	return chrePublishRpcServices(servicesA, 2 /* numServices */) &&
	chrePublishRpcServices(servicesB, 2 /* numServices */);
	}
	};

	uint64_t appId = loadNanoapp(MakeUnique<App>());
	Nanoapp *napp = getNanoappByAppId(appId);
	ASSERT_NE(napp, nullptr);

	EXPECT_EQ(napp->getRpcServices().size(), 4);
	EXPECT_EQ(napp->getRpcServices()[0].id, 1);
	EXPECT_EQ(napp->getRpcServices()[1].id, 2);
	EXPECT_EQ(napp->getRpcServices()[2].id, 3);
	EXPECT_EQ(napp->getRpcServices()[3].id, 4);
	}

	TEST_F(TestBase, PwRpcCanNotPublishDuplicateServices) {
	class App : public TestNanoapp {
	bool start() override {
	struct chreNanoappRpcService servicesA[] = {
	{.id = 1, .version = 0},
	{.id = 2, .version = 0},
	};

	bool success = chrePublishRpcServices(servicesA, 2 /* numServices */);

	EXPECT_FALSE(chrePublishRpcServices(servicesA, 2 /* numServices */));

	struct chreNanoappRpcService servicesB[] = {
	{.id = 5, .version = 0},
	{.id = 5, .version = 0},
	};

	EXPECT_FALSE(chrePublishRpcServices(servicesB, 2 /* numServices */));

	return success;
	}
	};

	uint64_t appId = loadNanoapp(MakeUnique<App>());
	Nanoapp *napp = getNanoappByAppId(appId);
	ASSERT_NE(napp, nullptr);

	EXPECT_EQ(napp->getRpcServices().size(), 2);
	EXPECT_EQ(napp->getRpcServices()[0].id, 1);
	EXPECT_EQ(napp->getRpcServices()[1].id, 2);
	}

	TEST_F(TestBase, PwRpcDifferentAppCanPublishSameServices) {
	class App : public TestNanoapp {
	public:
	explicit App(uint64_t id) : TestNanoapp(TestNanoappInfo{.id = id}) {}

	bool start() override {
	struct chreNanoappRpcService services[] = {
	{.id = 1, .version = 0},
	{.id = 2, .version = 0},
	};

	return chrePublishRpcServices(services, 2 /* numServices */);
	}
	};

	uint64_t app1Id = loadNanoapp(MakeUnique<App>(0x01));
	uint64_t app2Id = loadNanoapp(MakeUnique<App>(0x02));
	Nanoapp *napp1 = getNanoappByAppId(app1Id);
	ASSERT_NE(napp1, nullptr);

	EXPECT_EQ(napp1->getRpcServices().size(), 2);
	EXPECT_EQ(napp1->getRpcServices()[0].id, 1);
	EXPECT_EQ(napp1->getRpcServices()[1].id, 2);

	Nanoapp *napp2 = getNanoappByAppId(app2Id);
	ASSERT_NE(napp2, nullptr);

	EXPECT_EQ(napp2->getRpcServices().size(), 2);
	EXPECT_EQ(napp2->getRpcServices()[0].id, 1);
	EXPECT_EQ(napp2->getRpcServices()[1].id, 2);
	}

	TEST_F(TestBase, PwRpcCanNotPublishServicesOutsideOfNanoappStart) {
	CREATE_CHRE_TEST_EVENT(PUBLISH_SERVICES, 0);

	class App : public TestNanoapp {
	public:
	void handleEvent(uint32_t, uint16_t eventType,
	const void *eventData) override {
	switch (eventType) {
	case CHRE_EVENT_TEST_EVENT: {
	auto event = static_cast<const TestEvent *>(eventData);
	switch (event->type) {
	case PUBLISH_SERVICES: {
	struct chreNanoappRpcService services[] = {
	{.id = 1, .version = 0},
	{.id = 2, .version = 0},
	};

	bool success =
	chrePublishRpcServices(services, 2 /* numServices */);
	TestEventQueueSingleton::get()->pushEvent(PUBLISH_SERVICES,
	success);
	break;
	}
	}
	}
	}
	}
	};

	uint64_t appId = loadNanoapp(MakeUnique<App>());

	bool success = true;
	sendEventToNanoapp(appId, PUBLISH_SERVICES);
	waitForEvent(PUBLISH_SERVICES, &success);
	EXPECT_FALSE(success);

	Nanoapp *napp = getNanoappByAppId(appId);
	ASSERT_NE(napp, nullptr);

	EXPECT_EQ(napp->getRpcServices().size(), 0);
	}

	TEST_F(TestBase, PwRpcRegisterServicesShouldGracefullyFailOnDuplicatedService) {
	class App : public TestNanoapp {
	public:
	bool start() override {
	static RpcTestService testService;

	chre::RpcServer::Service service = {.service = testService,
	.id = 0xca8f7150a3f05847,
	.version = 0x01020034};

	chre::RpcServer &server = EnvSingleton::get()->mServer;

	bool status = server.registerServices(1, &service);

	EXPECT_TRUE(status);

	EXPECT_FALSE(server.registerServices(1, &service));

	return status;
	}

	void end() override {
	EnvSingleton::get()->closeServer();
	}
	};

	EnvSingleton::init();
	uint64_t appId = loadNanoapp(MakeUnique<App>());
	unloadNanoapp(appId);
	EnvSingleton::deinit();
	}

	TEST_F(TestBase, PwRpcGetNanoappInfoByAppIdReturnsServices) {
	CREATE_CHRE_TEST_EVENT(QUERY_INFO, 0);

	class App : public TestNanoapp {
	public:
	bool start() override {
	struct chreNanoappRpcService services[] = {
	{.id = 1, .version = 2},
	{.id = 2, .version = 3},
	};

	return chrePublishRpcServices(services, 2 /* numServices */);
	}

	void handleEvent(uint32_t, uint16_t eventType,
	const void *eventData) override {
	switch (eventType) {
	case CHRE_EVENT_TEST_EVENT: {
	auto event = static_cast<const TestEvent *>(eventData);
	switch (event->type) {
	case QUERY_INFO: {
	auto id = static_cast<uint64_t *>(event->data);
	bool success = chreGetNanoappInfoByAppId(*id, &mInfo);
	const struct chreNanoappInfo *pInfo = success ? &mInfo : nullptr;
	TestEventQueueSingleton::get()->pushEvent(QUERY_INFO, pInfo);
	break;
	}
	}
	}
	}
	}

	protected:
	struct chreNanoappInfo mInfo;
	};

	uint64_t appId = loadNanoapp(MakeUnique<App>());

	struct chreNanoappInfo *pInfo = nullptr;
	sendEventToNanoapp(appId, QUERY_INFO, appId);
	waitForEvent(QUERY_INFO, &pInfo);
	EXPECT_TRUE(pInfo != nullptr);
	EXPECT_EQ(pInfo->rpcServiceCount, 2);
	EXPECT_EQ(pInfo->rpcServices[0].id, 1);
	EXPECT_EQ(pInfo->rpcServices[0].version, 2);
	EXPECT_EQ(pInfo->rpcServices[1].id, 2);
	EXPECT_EQ(pInfo->rpcServices[1].version, 3);
	EXPECT_EQ(pInfo->reserved[0], 0);
	EXPECT_EQ(pInfo->reserved[1], 0);
	EXPECT_EQ(pInfo->reserved[2], 0);
	}

	TEST_F(TestBase, PwRpcClientNanoappCanRequestServerNanoapp) {
	CREATE_CHRE_TEST_EVENT(INCREMENT_REQUEST, 0);

	class ClientApp : public TestNanoapp {
	public:
	ClientApp() : TestNanoapp(TestNanoappInfo{.id = kPwRcpClientAppId}) {}

	void handleEvent(uint32_t senderInstanceId, uint16_t eventType,
	const void *eventData) override {
	Env *env = EnvSingleton::get();

	env->mClient.handleEvent(senderInstanceId, eventType, eventData);
	switch (eventType) {
	case CHRE_EVENT_TEST_EVENT: {
	auto event = static_cast<const TestEvent *>(eventData);
	switch (event->type) {
	case INCREMENT_REQUEST: {
	auto client =
	env->mClient
	.get<rpc::pw_rpc::nanopb::RpcTestService::Client>();
	if (client.has_value()) {
	chre_rpc_NumberMessage incrementRequest;
	incrementRequest.number = static_cast<uint32_t >(event->data);
	env->mIncrementCall = client->Increment(
	incrementRequest, [](const chre_rpc_NumberMessage &response,
	pw::Status status) {
	if (status.ok()) {
	EnvSingleton::get()->mNumber = response.number;
	TestEventQueueSingleton::get()->pushEvent(
	INCREMENT_REQUEST, true);
	} else {
	TestEventQueueSingleton::get()->pushEvent(
	INCREMENT_REQUEST, false);
	}
	});
	} else {
	TestEventQueueSingleton::get()->pushEvent(INCREMENT_REQUEST,
	false);
	}
	}
	}
	}
	}
	}

	void end() {
	EnvSingleton::get()->closeClient();
	}
	};

	class ServerApp : public TestNanoapp {
	public:
	ServerApp() : TestNanoapp(TestNanoappInfo{.id = kPwRcpServerAppId}) {}

	bool start() override {
	chre::RpcServer::Service service = {
	.service = EnvSingleton::get()->mRpcTestService,
	.id = 0xca8f7150a3f05847,
	.version = 0x01020034};
	return EnvSingleton::get()->mServer.registerServices(1, &service);
	}

	void handleEvent(uint32_t senderInstanceId, uint16_t eventType,
	const void *eventData) override {
	EnvSingleton::get()->mServer.handleEvent(senderInstanceId, eventType,
	eventData);
	}

	void end() {
	EnvSingleton::get()->closeServer();
	}
	};

	EnvSingleton::init();
	uint64_t serverId = loadNanoapp(MakeUnique<ServerApp>());
	uint64_t clientId = loadNanoapp(MakeUnique<ClientApp>());
	bool status;
	constexpr uint32_t kNumber = 101;

	sendEventToNanoapp(clientId, INCREMENT_REQUEST, kNumber);
	waitForEvent(INCREMENT_REQUEST, &status);
	EXPECT_TRUE(status);
	EXPECT_EQ(EnvSingleton::get()->mNumber, kNumber + 1);
	unloadNanoapp(serverId);
	unloadNanoapp(clientId);
	EnvSingleton::deinit();
	}

	TEST_F(TestBase, PwRpcRpcClientHasServiceCheckForAMatchingService) {
	CREATE_CHRE_TEST_EVENT(QUERY_HAS_SERVICE, 0);

	struct ServiceInfo {
	uint64_t id;
	uint32_t version;
	uint64_t appId;
	};

	class App : public TestNanoapp {
	public:
	bool start() override {
	struct chreNanoappRpcService services[] = {{.id = 1, .version = 2}};

	return chrePublishRpcServices(services, 1 /* numServices */);
	}

	void handleEvent(uint32_t, uint16_t eventType, const void *eventData) {
	switch (eventType) {
	case CHRE_EVENT_TEST_EVENT: {
	auto event = static_cast<const TestEvent *>(eventData);
	switch (event->type) {
	case QUERY_HAS_SERVICE: {
	auto service =
	static_cast<const struct ServiceInfo *>(event->data);
	RpcClient client{service->appId};
	bool hasService =
	client.hasService(service->id, service->version);
	TestEventQueueSingleton::get()->pushEvent(QUERY_HAS_SERVICE,
	hasService);
	break;
	}
	}
	break;
	}
	}
	}
	};

	uint64_t appId = loadNanoapp(MakeUnique<App>());

	ServiceInfo service;
	bool hasService = false;

	service = {.id = 1, .version = 2, .appId = appId};
	sendEventToNanoapp(appId, QUERY_HAS_SERVICE, service);
	waitForEvent(QUERY_HAS_SERVICE, &hasService);
	EXPECT_TRUE(hasService);
	service = {.id = 10, .version = 2, .appId = appId};
	sendEventToNanoapp(appId, QUERY_HAS_SERVICE, service);
	waitForEvent(QUERY_HAS_SERVICE, &hasService);
	EXPECT_FALSE(hasService);
	}

	} // namespace

	} // namespace chre