#include <tcore.h>
#include <server.h>
+#include <plugin.h>
+#include <core_object.h>
+
using ::testing::EmptyTestEventListener;
using ::testing::InitGoogleTest;
ASSERT_TRUE(modem_count > 0);
}
+TEST(LIBTCORE_OBJECT, test_object_new)
+{
+ TReturn ret;
+ CoreObject *co;
+ TcorePlugin *test_plugin = tcore_plugin_new(NULL, NULL, NULL, NULL) ;
+ g_assert(test_plugin);
+
+ co = tcore_object_new(test_plugin, "test1", NULL);
+ ASSERT_TRUE(co) << "tcore_object_new() failed" << std::endl;
+
+ ret = tcore_object_set_free_hook(co, NULL);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_set_free_hook() is failed" << std::endl;
+
+ EXPECT_EQ(tcore_object_ref_subscription_type(co) , TELEPHONY_SUBSCRIPTION_TYPE_DEFAULT) << "subscription type is not matched" << std::endl;
+
+ tcore_object_ref_plugin(co);
+
+ char po[] = "test_object";
+ char *ref_po = NULL;
+
+ ret = tcore_object_link_object(co, po);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_link_object() is failed" << std::endl;
+ ref_po = (char *)tcore_object_ref_object(co);
+ std::cout << " ref_object: " << ref_po << std::endl;
+ EXPECT_EQ(strcmp(po, ref_po), 0) << "object is not matched" << std::endl;
+
+ ret = tcore_object_set_hal(co, NULL);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_set_hal() is failed" << std::endl;
+ tcore_object_get_hal(co);
+
+ char userdata[] = "test_userdata";
+ char *ref_userdata = NULL;
+ ret = tcore_object_link_user_data(co, userdata);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_link_user_data() is failed" << std::endl;
+ ref_userdata = (char *)tcore_object_ref_user_data(co);
+ std::cout << " ref_userdata: " << ref_userdata<< std::endl;
+ EXPECT_EQ(strcmp(userdata, ref_userdata), 0) << "userdata is not matched" << std::endl;
+
+ ret = tcore_object_set_name(co, "test2");
+ EXPECT_EQ(TCORE_RETURN_SUCCESS, ret) << "tcore_object_set_name() is failed" << std::endl;
+
+ std::cout << " Name: " << tcore_object_ref_name(co) << std::endl;
+ EXPECT_EQ(strcmp(tcore_object_ref_name(co), "test2"), 0) << "object name is not matched" << std::endl;
+
+ tcore_object_set_type(co, CORE_OBJECT_TYPE_CUSTOM);
+ EXPECT_EQ(tcore_object_get_type(co) , CORE_OBJECT_TYPE_CUSTOM) << "object type is not matched" << std::endl;
+
+ tcore_object_free(co);
+}
+
+static int _event1_count = 0;
+static int _event2_count = 0;
+
+static gboolean __on_event1(CoreObject *o, const void *event_info, void *user_data)
+{
+ _event1_count++;
+
+ g_assert(o);
+ g_assert(event_info);
+ g_assert_cmpstr((char *)event_info, ==, "ok");
+
+ return TRUE;
+}
+static gboolean __on_event2(CoreObject *o, const void *event_info, void *user_data)
+{
+ _event2_count++;
+
+ g_assert(o);
+ g_assert(event_info);
+ g_assert_cmpstr((char *)event_info, ==, "ok");
+
+ return TRUE;
+}
+
+static gboolean __on_event3(CoreObject *o, const void *event_info, void *user_data)
+{
+ _event2_count++;
+
+ g_assert(o);
+ g_assert(event_info);
+ g_assert_cmpstr((char *)event_info, ==, "ok");
+
+ return TRUE;
+}
+
+
+TEST(LIBTCORE_OBJECT, test_object_callback)
+{
+ CoreObject *co;
+ TReturn ret;
+
+ co = tcore_object_new(NULL, "test", NULL);
+ ASSERT_TRUE(co) << "tcore_object_new() failed" << std::endl;
+
+ /* lifetime: unlimit */
+ _event1_count = 0;
+ ret = tcore_object_add_callback(co, "event1", __on_event1, NULL);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_add_callback() is failed" << std::endl;
+
+ ret = tcore_object_emit_callback(co, "event1", "ok");
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_emit_callback() is failed" << std::endl;
+
+ ret = tcore_object_emit_callback(co, "event1", "ok");
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_emit_callback() is failed" << std::endl;
+
+ EXPECT_EQ(_event1_count, 2) << "_event1_count is not matched" << std::endl;
+
+ _event2_count = 0;
+ ret = tcore_object_add_callback(co, "event2", __on_event2, NULL);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_add_callback() is failed" << std::endl;
+
+ ret = tcore_object_emit_callback(co, "event2", "ok");
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_emit_callback() is failed" << std::endl;
+
+ ret = tcore_object_del_callback(co, "event1", __on_event1);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_del_callback() is failed" << std::endl;
+
+ ret = tcore_object_override_callback(co, "event1", __on_event3, NULL);
+ EXPECT_EQ(ret, TCORE_RETURN_SUCCESS) << "tcore_object_override_callback() is failed" << std::endl;
+
+ tcore_object_free(co);
+}
+
+
+static gboolean on_prop_changed(CoreObject *co, const void *event_info, void *user_data)
+{
+ int *mode = (int *)user_data;
+ GSList *key = (GSList *)event_info;
+ const char *data;
+
+ switch (*mode) {
+ case 1:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "qqq");
+ data = tcore_object_ref_property(co, "qqq");
+ g_assert_cmpstr(data, ==, "1234");
+ break;
+
+ case 2:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "qqq");
+ data = tcore_object_ref_property(co, "qqq");
+ g_assert(data == NULL);
+ break;
+
+ case 3:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "www");
+ data = tcore_object_ref_property(co, "www");
+ g_assert_cmpstr(data, ==, "heap");
+ break;
+
+ case 4:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "www");
+ data = tcore_object_ref_property(co, "www");
+ g_assert(data == NULL);
+ break;
+
+ case 5:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "key");
+ data = tcore_object_ref_property(co, "key");
+ g_assert_cmpstr(data, ==, "1");
+ break;
+
+ case 6:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "key");
+ data = tcore_object_ref_property(co, "key");
+ g_assert_cmpstr(data, ==, "2");
+ break;
+
+ case 7:
+ g_assert(FALSE);
+ break;
+
+ case 8:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "key");
+ data = tcore_object_ref_property(co, "key");
+ g_assert_cmpstr(data, ==, "2");
+ break;
+
+ case 9:
+ g_assert(g_slist_length(key) == 2);
+ g_assert_cmpstr((char *)key->data, ==, "foo");
+ g_assert_cmpstr((char *)key->next->data, ==, "bar");
+ data = tcore_object_ref_property(co, "foo");
+ g_assert_cmpstr(data, ==, "1");
+ data = tcore_object_ref_property(co, "bar");
+ g_assert_cmpstr(data, ==, "2");
+ break;
+
+ case 10:
+ g_assert(g_slist_length(key) == 1);
+ g_assert_cmpstr((char *)key->data, ==, "foo");
+ data = tcore_object_ref_property(co, "foo");
+ g_assert(data == NULL);
+ break;
+
+ case 11:
+ g_assert(g_slist_length(key) == 2);
+ g_assert(g_slist_find_custom(key, "foo",
+ (GCompareFunc)g_strcmp0) != NULL);
+ g_assert(CORE_OBJECT_KEY_FIND(key, "bar") != NULL);
+ data = tcore_object_ref_property(co, "foo");
+ g_assert_cmpstr(data, ==, "1");
+ data = tcore_object_ref_property(co, "bar");
+ g_assert(data == NULL);
+ break;
+
+ default:
+ g_assert(FALSE);
+ break;
+ }
+
+ /* Set flag to callback invocation success */
+ *mode = 0;
+
+ return TRUE;
+}
+
+TEST(LIBTCORE_OBJECT, test_object_property)
+{
+ CoreObject *co;
+ const char *data;
+ char *test;
+ GHashTable *raw;
+ int mode = 0;
+ GSList *tmp_list;
+
+ co = tcore_object_new(NULL, "test", NULL);
+ g_assert(co);
+
+ tcore_object_add_callback(co, CORE_OBJECT_EVENT_PROPERTY_CHANGED,
+ on_prop_changed, &mode);
+
+ raw = tcore_object_ref_property_hash(co);
+ g_assert(raw);
+
+ /* Case: Basic property set */
+ mode = 1;
+ tcore_object_set_property(co, "qqq", "1234");
+ g_assert(g_hash_table_size(raw) == 1);
+ g_assert(mode == 0);
+
+ data = tcore_object_ref_property(co, "qqq");
+ g_assert_cmpstr(data, ==, "1234");
+
+ /* Case: Basic property remove */
+ mode = 2;
+ tcore_object_set_property(co, "qqq", NULL);
+ g_assert(g_hash_table_size(raw) == 0);
+ g_assert(mode == 0);
+
+ data = tcore_object_ref_property(co, "qqq");
+ g_assert(data == NULL);
+
+ /* Case: Malloc property set */
+ mode = 3;
+ test = strdup("heap");
+ tcore_object_set_property(co, "www", test);
+ g_assert(g_hash_table_size(raw) == 1);
+ g_assert(mode == 0);
+ free(test);
+
+ data = tcore_object_ref_property(co, "www");
+ g_assert_cmpstr(data, ==, "heap");
+
+ /* Case: Malloc property remove */
+ mode = 4;
+ tcore_object_set_property(co, "www", NULL);
+ g_assert(g_hash_table_size(raw) == 0);
+ g_assert(mode == 0);
+
+ data = tcore_object_ref_property(co, "www");
+ g_assert(data == NULL);
+
+ /* Case: Same key & Different value set */
+ mode = 5;
+ tcore_object_set_property(co, "key", "1");
+ g_assert(g_hash_table_size(raw) == 1);
+ g_assert(mode == 0);
+
+ mode = 6;
+ tcore_object_set_property(co, "key", "2");
+ g_assert(g_hash_table_size(raw) == 1);
+ g_assert(mode == 0);
+
+ /* Case: Same key & Same value set => No callback invocation */
+ mode = 7;
+ tcore_object_set_property(co, "key", "2");
+ g_assert(g_hash_table_size(raw) == 1);
+ g_assert(mode == 7);
+
+ /* Case: Same key & Same value set & force event invocation */
+ mode = 8;
+ tcore_object_set_property(co, "key", "2");
+ g_assert(g_hash_table_size(raw) == 1);
+
+ tmp_list = g_slist_append(NULL, (char *)"key");
+ tcore_object_emit_callback(co, CORE_OBJECT_EVENT_PROPERTY_CHANGED, tmp_list);
+ g_assert(mode == 0);
+ g_slist_free(tmp_list);
+
+ /* Case: Multiple property set */
+ mode = 9;
+ tcore_object_set_property(co, "foo", "1", "bar", "2");
+ g_assert(g_hash_table_size(raw) == 3);
+ g_assert(mode == 0);
+
+ /* Case: Set key without value => same as key with NULL: remove key */
+ mode = 10;
+ tcore_object_set_property(co, "foo");
+ g_assert(g_hash_table_size(raw) == 2);
+ g_assert(mode == 0);
+
+ /* Case: Multiple property set with unset (foo set, bar unset) */
+ mode = 11;
+ tcore_object_set_property(co, "foo", "1", "bar");
+ g_assert(g_hash_table_size(raw) == 2);
+ g_assert(mode == 0);
+
+ tcore_object_free(co);
+}
+
+
+TEST(LIBTCORE_UTIL, test_util_marshal)
+{
+ GHashTable *list;
+ int value_int;
+
+ list = tcore_util_marshal_create();
+ ASSERT_TRUE(list) << "tcore_util_marshal_create() failed" << std::endl;
+
+ value_int = 1;
+ tcore_util_marshal_add_data(list, "key1", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
+ ASSERT_TRUE(tcore_util_marshal_get_int(list, "key1") == value_int);
+
+ value_int = 2;
+ tcore_util_marshal_add_data(list, "key2", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
+ ASSERT_TRUE(tcore_util_marshal_get_int(list, "key2") == value_int);
+
+ tcore_util_marshal_destory(list);
+}
+
+TEST(LIBTCORE_UTIL, test_util_marshal_serialize)
+{
+ GHashTable *list;
+ GHashTable *item;
+ GHashTable *tmp;
+ gchar *serialized;
+ int i;
+ char buf[255];
+ int value_int;
+
+ list = tcore_util_marshal_create();
+ ASSERT_TRUE(list);
+
+ value_int = 1;
+ tcore_util_marshal_add_data(list, "key1", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
+ ASSERT_TRUE(tcore_util_marshal_get_int(list, "key1") == value_int);
+
+ value_int = 2;
+ tcore_util_marshal_add_data(list, "key2", &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
+ ASSERT_TRUE(tcore_util_marshal_get_int(list, "key2") == value_int);
+
+ const char str[] = "key_string";
+ tcore_util_marshal_add_data(list, "key3", str, TCORE_UTIL_MARSHAL_DATA_STRING_TYPE);
+ ASSERT_TRUE(strcmp(tcore_util_marshal_get_string(list, "key3"), str) == 0);
+
+ item = tcore_util_marshal_create();
+ ASSERT_TRUE(item);
+ tcore_util_marshal_add_data(list, "key_object", item, TCORE_UTIL_MARSHAL_DATA_OBJECT_TYPE);
+
+ for (i = 0; i < 3; i++) {
+ item = tcore_util_marshal_create();
+ ASSERT_TRUE(item);
+
+ value_int = i * 10;
+ snprintf(buf, 255, "sub-%d", i);
+ tcore_util_marshal_add_data(item, buf, &value_int, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
+ ASSERT_TRUE(tcore_util_marshal_get_int(item, buf) == value_int);
+
+ tcore_util_marshal_add_data(list, buf, item, TCORE_UTIL_MARSHAL_DATA_OBJECT_TYPE);
+ }
+
+ serialized = tcore_util_marshal_serialize(list);
+ ASSERT_TRUE(serialized);
+ tcore_util_marshal_destory(list);
+
+ tmp = tcore_util_marshal_deserialize_string(serialized);
+ ASSERT_TRUE(tmp);
+
+ free(serialized);
+
+ ASSERT_TRUE(tcore_util_marshal_get_int(tmp, "key1") == 1);
+ ASSERT_TRUE(tcore_util_marshal_get_int(tmp, "key2") == 2);
+
+ tcore_util_marshal_destory(tmp);
+}
+
+TEST(LIBTCORE_UTIL, test_util_decode_hex)
+{
+ char *hex = (char *)"1A2B3C4D5E6F";
+ unsigned char expected[] = { 0x1A, 0x2B, 0x3C, 0x4D, 0x5E, 0x6F };
+ unsigned char *dest;
+
+ dest = tcore_util_decode_hex(hex, strlen(hex));
+ ASSERT_TRUE(memcmp(dest, expected, strlen((char *)dest)) == 0);
+ free(dest);
+}
+
+TEST(LIBTCORE_UTIL, test_util_hex_dump)
+{
+ /* AT+CRSM=command>[, <fileid>[, <P1>, <P2>, <P3>[, <data>[, <pathid>]]]] */
+ char *cmd_str = g_strdup_printf("AT+CRSM=192, 28482");
+
+ tcore_util_hex_dump(" ", strlen(cmd_str), (void *)cmd_str);
+
+ /* Free resources */
+ g_free(cmd_str);
+
+}
+
+TEST(LIBTCORE_UTIL, test_util_gsm7bit)
+{
+ unsigned char *dest;
+ unsigned char packed[] = { 0xE8, 0x32, 0x9B, 0xFD, 0x06, 0x00 };
+
+ std::cout << std::endl;
+ /* unpack packed-data('hello') */
+ dest = tcore_util_unpack_gsm7bit(packed, 0x05);
+ g_assert_cmpstr((char *)dest, ==, "hello");
+ free(dest);
+
+ /* pack 'hello' */
+ dest = tcore_util_pack_gsm7bit((unsigned char *)"hello", strlen("hello"));
+
+ if (dest) {
+ g_assert(memcmp(packed, dest, strlen((char *)dest)) == 0);
+ free(dest);
+ }
+}
+
+TEST(LIBTCORE_UTIL, test_util_get_version)
+{
+ char *version;
+
+ version = tcore_util_get_version();
+ ASSERT_TRUE(version) << "tcore_util_get_version() failed" << std::endl;
+
+ if (version) {
+ std::cout << " libtcore version: " << version << std::endl;
+ free(version);
+ }
+}
+
+TEST(LIBTCORE_UTIL, test_util_set_log)
+{
+ tcore_util_set_log(FALSE);
+ tcore_util_set_log(TRUE);
+}
+
+TEST(LIBTCORE_UTIL, test_util_is_country_NA)
+{
+ char plmn1[] = "31033";
+ ASSERT_TRUE(tcore_util_is_country_NA(plmn1) == TRUE);
+
+ char plmn2[] = "45001";
+ ASSERT_TRUE(tcore_util_is_country_NA(plmn2) == FALSE);
+}
+
int main(int argc, char **argv) {
InitGoogleTest(&argc, argv);
projects / platform / core / telephony / libtcore.git / commitdiff