ubports-volte/libgbinder
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[unit] Improved gbinder_servicemanager_aidl coverage. JB#42956

Browse Source 
Also made ServiceManagerAidl a GBinderLocalObject-derived class to prepare
for possibly making it (deriving classes from GBinderLocalObject) a public
functionality.
This commit is contained in:
Slava Monich
2020-12-23 18:19:51 +02:00
parent 83cc13b817
commit 5fbaabb47e
1 changed files with 160 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
unit/unit_servicemanager_aidl/unit_servicemanager_aidl.c
View File

@@ -33,22 +33,18 @@
#include "test_binder.h"
#include "gbinder_driver.h"
#include "gbinder_config.h"
#include "gbinder_ipc.h"
#include "gbinder_reader.h"
#include "gbinder_servicemanager_p.h"
#include "gbinder_rpc_protocol.h"
#include "gbinder_local_object.h"
#include "gbinder_local_object_p.h"
#include "gbinder_local_reply.h"
#include "gbinder_remote_request.h"
#include "gbinder_remote_object.h"
#include <gutil_strv.h>
#include <gutil_macros.h>
#include <gutil_log.h>
#include <errno.h>
static TestOpt test_opt;
GType
@@ -70,7 +66,7 @@ gbinder_servicemanager_aidl2_get_type()
*==========================================================================*/
#define SVCMGR_HANDLE (0)
static const char SVCMGR[] = "android.os.IServiceManager";
static const char SVCMGR_IFACE[] = "android.os.IServiceManager";
enum servicemanager_aidl_tx {
GET_SERVICE_TRANSACTION = GBINDER_FIRST_CALL_TRANSACTION,
CHECK_SERVICE_TRANSACTION,
@@ -78,12 +74,20 @@ enum servicemanager_aidl_tx {
LIST_SERVICES_TRANSACTION
};
const char* const servicemanager_aidl_ifaces[] = { SVCMGR, NULL };
const char* const servicemanager_aidl_ifaces[] = { SVCMGR_IFACE, NULL };
typedef struct test_service_manager {
GBinderLocalObject* obj;
typedef GBinderLocalObjectClass ServiceManagerAidlClass;
typedef struct service_manager_aidl {
GBinderLocalObject parent;
GHashTable* objects;
} TestServiceManager;
gboolean handle_on_looper_thread;
} ServiceManagerAidl;
#define SERVICE_MANAGER_AIDL_TYPE (service_manager_aidl_get_type())
#define SERVICE_MANAGER_AIDL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
SERVICE_MANAGER_AIDL_TYPE, ServiceManagerAidl))
G_DEFINE_TYPE(ServiceManagerAidl, service_manager_aidl, \
GBINDER_TYPE_LOCAL_OBJECT)
static
GBinderLocalReply*
@@ -95,7 +99,7 @@ servicemanager_aidl_handler(
int* status,
void* user_data)
{
TestServiceManager* self = user_data;
ServiceManagerAidl* self = user_data;
GBinderLocalReply* reply = NULL;
GBinderReader reader;
GBinderRemoteObject* remote_obj;
@@ -103,7 +107,7 @@ servicemanager_aidl_handler(
char* str;
g_assert(!flags);
g_assert_cmpstr(gbinder_remote_request_interface(req), == ,SVCMGR);
g_assert_cmpstr(gbinder_remote_request_interface(req), == ,SVCMGR_IFACE);
*status = -1;
switch (code) {
case GET_SERVICE_TRANSACTION:
@@ -161,20 +165,22 @@ servicemanager_aidl_handler(
}
static
TestServiceManager*
ServiceManagerAidl*
servicemanager_aidl_new(
const char* dev)
const char* dev,
gboolean handle_on_looper_thread)
{
TestServiceManager* self = g_new0(TestServiceManager, 1);
ServiceManagerAidl* self = g_object_new(SERVICE_MANAGER_AIDL_TYPE, NULL);
GBinderLocalObject* obj = GBINDER_LOCAL_OBJECT(self);
GBinderIpc* ipc = gbinder_ipc_new(dev);
const int fd = gbinder_driver_fd(ipc->driver);
self->objects = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
(GDestroyNotify) gbinder_remote_object_unref);
self->obj = gbinder_local_object_new(ipc, servicemanager_aidl_ifaces,
self->handle_on_looper_thread = handle_on_looper_thread;
gbinder_local_object_init_base(obj, ipc, servicemanager_aidl_ifaces,
servicemanager_aidl_handler, self);
test_binder_set_looper_enabled(fd, TRUE);
test_binder_register_object(fd, self->obj, SVCMGR_HANDLE);
test_binder_register_object(fd, obj, SVCMGR_HANDLE);
gbinder_ipc_register_local_object(ipc, obj);
gbinder_ipc_unref(ipc);
return self;
}
@@ -182,11 +188,79 @@ servicemanager_aidl_new(
static
void
servicemanager_aidl_free(
TestServiceManager* self)
ServiceManagerAidl* self)
{
gbinder_local_object_drop(self->obj);
gbinder_local_object_drop(GBINDER_LOCAL_OBJECT(self));
}
static
GBINDER_LOCAL_TRANSACTION_SUPPORT
service_manager_aidl_can_handle_transaction(
GBinderLocalObject* object,
const char* iface,
guint code)
{
ServiceManagerAidl* self = SERVICE_MANAGER_AIDL(object);
if (self->handle_on_looper_thread && !g_strcmp0(SVCMGR_IFACE, iface)) {
return GBINDER_LOCAL_TRANSACTION_LOOPER;
} else {
return GBINDER_LOCAL_OBJECT_CLASS(service_manager_aidl_parent_class)->
can_handle_transaction(object, iface, code);
}
}
static
GBinderLocalReply*
service_manager_aidl_handle_looper_transaction(
GBinderLocalObject* object,
GBinderRemoteRequest* req,
guint code,
guint flags,
int* status)
{
if (!g_strcmp0(gbinder_remote_request_interface(req), SVCMGR_IFACE)) {
return GBINDER_LOCAL_OBJECT_CLASS(service_manager_aidl_parent_class)->
handle_transaction(object, req, code, flags, status);
} else {
return GBINDER_LOCAL_OBJECT_CLASS(service_manager_aidl_parent_class)->
handle_looper_transaction(object, req, code, flags, status);
}
}
static
void
service_manager_aidl_finalize(
GObject* object)
{
ServiceManagerAidl* self = SERVICE_MANAGER_AIDL(object);
g_hash_table_destroy(self->objects);
g_free(self);
G_OBJECT_CLASS(service_manager_aidl_parent_class)->finalize(object);
}
static
void
service_manager_aidl_init(
ServiceManagerAidl* self)
{
self->objects = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
(GDestroyNotify) gbinder_remote_object_unref);
}
static
void
service_manager_aidl_class_init(
ServiceManagerAidlClass* klass)
{
GObjectClass* object = G_OBJECT_CLASS(klass);
GBinderLocalObjectClass* local_object = GBINDER_LOCAL_OBJECT_CLASS(klass);
object->finalize = service_manager_aidl_finalize;
local_object->can_handle_transaction =
service_manager_aidl_can_handle_transaction;
local_object->handle_looper_transaction =
service_manager_aidl_handle_looper_transaction;
}
/*==========================================================================*
@@ -239,7 +313,7 @@ test_get()
const char* dev = GBINDER_DEFAULT_BINDER;
const char* other_dev = GBINDER_DEFAULT_BINDER "-private";
GBinderIpc* ipc = gbinder_ipc_new(dev);
TestServiceManager* smsvc = servicemanager_aidl_new(other_dev);
ServiceManagerAidl* smsvc = servicemanager_aidl_new(other_dev, FALSE);
GBinderLocalObject* obj = gbinder_local_object_new(ipc, NULL, NULL, NULL);
const int fd = gbinder_driver_fd(ipc->driver);
const char* name = "name";
@@ -266,7 +340,7 @@ test_get()
g_assert_cmpuint(g_hash_table_size(smsvc->objects), == ,1);
g_assert(g_hash_table_contains(smsvc->objects, name));
/* Query the object (it should be there not) and wait for completion */
/* Query the object (this time it must be there) and wait for completion */
GDEBUG("Querying '%s' again", name);
g_assert(gbinder_servicemanager_get_service(sm, name, test_get_cb, loop));
test_run(&test_opt, loop);
@@ -313,7 +387,7 @@ test_list()
const char* dev = GBINDER_DEFAULT_BINDER;
const char* other_dev = GBINDER_DEFAULT_BINDER "-private";
GBinderIpc* ipc = gbinder_ipc_new(dev);
TestServiceManager* smsvc = servicemanager_aidl_new(other_dev);
ServiceManagerAidl* smsvc = servicemanager_aidl_new(other_dev, FALSE);
GBinderLocalObject* obj = gbinder_local_object_new(ipc, NULL, NULL, NULL);
const int fd = gbinder_driver_fd(ipc->driver);
const char* name = "name";
@@ -384,7 +458,7 @@ test_notify()
const char* dev = GBINDER_DEFAULT_BINDER;
const char* other_dev = GBINDER_DEFAULT_BINDER "-private";
GBinderIpc* ipc = gbinder_ipc_new(dev);
TestServiceManager* smsvc = servicemanager_aidl_new(other_dev);
ServiceManagerAidl* svc = servicemanager_aidl_new(other_dev, FALSE);
GBinderLocalObject* obj = gbinder_local_object_new(ipc, NULL, NULL, NULL);
const int fd = gbinder_driver_fd(ipc->driver);
const char* name = "name";
@@ -412,6 +486,65 @@ test_notify()
test_run(&test_opt, loop);
gbinder_servicemanager_remove_handler(sm, id);
test_binder_unregister_objects(fd);
gbinder_local_object_unref(obj);
servicemanager_aidl_free(svc);
gbinder_servicemanager_unref(sm);
gbinder_ipc_unref(ipc);
gbinder_ipc_exit();
test_binder_exit_wait();
g_main_loop_unref(loop);
}
/*==========================================================================*
* notify2
*==========================================================================*/
static
void
test_notify2()
{
const char* dev = GBINDER_DEFAULT_BINDER;
const char* other_dev = GBINDER_DEFAULT_BINDER "-private";
GBinderIpc* ipc = gbinder_ipc_new(dev);
ServiceManagerAidl* smsvc = servicemanager_aidl_new(other_dev, TRUE);
GBinderLocalObject* obj = gbinder_local_object_new(ipc, NULL, NULL, NULL);
const int fd = gbinder_driver_fd(ipc->driver);
GBinderServiceManager* sm;
const char* name1 = "name1";
const char* name2 = "name2";
GMainLoop* loop = g_main_loop_new(NULL, FALSE);
gulong id1, id2;
/* Set up binder simulator */
test_binder_register_object(fd, obj, AUTO_HANDLE);
test_binder_set_passthrough(fd, TRUE);
sm = gbinder_servicemanager_new(dev);
gbinder_ipc_set_max_threads(ipc, 1);
/* Register the object synchronously (twice)*/
GDEBUG("Registering object '%s' => %p", name1, obj);
g_assert_cmpint(gbinder_servicemanager_add_service_sync(sm,name1,obj),==,0);
g_assert(gbinder_servicemanager_get_service_sync(sm, name1, NULL));
GDEBUG("Registering object '%s' => %p", name2, obj);
g_assert_cmpint(gbinder_servicemanager_add_service_sync(sm,name2,obj),==,0);
g_assert(gbinder_servicemanager_get_service_sync(sm, name2, NULL));
/* Watch for the first name to create internal name watcher */
id1 = gbinder_servicemanager_add_registration_handler(sm, name1,
test_notify_cb, loop);
g_assert(id1);
test_run(&test_opt, loop);
/* Now watch for the second name */
id2 = gbinder_servicemanager_add_registration_handler(sm, name2,
test_notify_cb, loop);
g_assert(id2);
test_run(&test_opt, loop);
gbinder_servicemanager_remove_handler(sm, id1);
gbinder_servicemanager_remove_handler(sm, id2);
test_binder_unregister_objects(fd);
gbinder_local_object_unref(obj);
servicemanager_aidl_free(smsvc);
@@ -434,6 +567,7 @@ int main(int argc, char* argv[])
g_test_add_func(TEST_("get"), test_get);
g_test_add_func(TEST_("list"), test_list);
g_test_add_func(TEST_("notify"), test_notify);
g_test_add_func(TEST_("notify2"), test_notify2);
test_init(&test_opt, argc, argv);
return g_test_run();
}