tests/mocks/uwb_mock.c

   1 //
   2 // Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16 #include <stdio.h>
  17 #include <stdarg.h>
  18 #include <stdbool.h>
  19 #include <string.h>
  20
  21 #include <glib.h>
  22 #include <gio/gio.h>
  23
  24 #ifndef API
  25 #define API __attribute__ ((visibility("default")))
  26 #endif
  27
  28 typedef enum {
  29         LOG_ID_INVALID = -1,
  30         LOG_ID_MAIN,
  31         LOG_ID_RADIO,
  32         LOG_ID_SYSTEM,
  33         LOG_ID_APPS,
  34         LOG_ID_KMSG,
  35         LOG_ID_SYSLOG,
  36         LOG_ID_MAX
  37 } log_id_t;
  38
  39 API int __dlog_print(log_id_t log_id, int prio, const char *tag, const char *fmt, ...)
  40 {
  41         va_list ap;
  42         va_start(ap, fmt);
  43         vprintf(fmt, ap);
  44         va_end(ap);
  45         printf("\n");
  46
  47         return 0;
  48 }
  49
  50 API int system_info_get_platform_bool(const char *key, bool *value)
  51 {
  52         *value = true;
  53         return 0;
  54 }
  55
  56 API gulong g_signal_connect_data(gpointer instance,
  57         const gchar *detailed_signal,
  58         GCallback c_handler,
  59         gpointer data,
  60         GClosureNotify destroy_data,
  61         GConnectFlags connect_flags)
  62 {
  63         return 0;
  64 }
  65
  66 API GVariant *g_variant_new(const gchar *format_string, ...)
  67 {
  68         return (void *)1234;
  69 }
  70
  71 API gsize g_variant_iter_init(GVariantIter *iter, GVariant *value)
  72 {
  73         return 0;
  74 }
  75
  76 API void g_object_unref(gpointer _object)
  77 {
  78         return;
  79 }
  80
  81 API gpointer g_initable_new(GType object_type, GCancellable *cancellable,
  82         GError **error, const gchar *first_property_name, ...)
  83 {
  84         return (void *)1234;
  85 }
  86
  87 API GTypeInstance *g_type_check_instance_cast(GTypeInstance *type_instance,
  88         GType iface_type)
  89 {
  90         return (void *)1234;
  91 }
  92
  93 API GVariant *g_dbus_proxy_call_sync(GDBusProxy *proxy, const gchar *method_name,
  94         GVariant *parameters, GDBusCallFlags flags, gint timeout_msec, GCancellable *cancellable,
  95         GError **error)
  96 {
  97         return (void *)1234;
  98 }
  99
 100 API void g_variant_unref (GVariant *value)
 101 {
 102         return;
 103 }
 104
 105 GAsyncReadyCallback _callback;
 106
 107 gboolean __get_network_info_cb(gpointer user_data)
 108 {
 109         _callback(NULL, NULL, user_data);
 110
 111         return FALSE;
 112 }
 113
 114 API void g_dbus_proxy_call (GDBusProxy *proxy, const gchar *method_name, GVariant *parameters,
 115         GDBusCallFlags flags, gint timeout_msec, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
 116 {
 117         _callback = callback;
 118
 119         if (0 == strncmp(method_name, "GetNetworkInfo", strlen(method_name))) {
 120                 g_timeout_add_seconds(1, __get_network_info_cb, user_data);
 121         }
 122
 123         return;
 124 }
 125
 126 API GVariant *g_dbus_proxy_call_finish(GDBusProxy *proxy, GAsyncResult *res, GError **error)
 127 {
 128         return (void *)1234;
 129 }
 130
 131 static GVariant *__create_dummy()
 132 {
 133         GVariant *va = NULL;
 134         GVariantBuilder *builder = NULL;
 135
 136         builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
 137         va = g_variant_builder_end(builder);
 138         g_variant_builder_unref(builder);
 139
 140         return va;
 141 }
 142
 143 static GVariant *__create_vardict()
 144 {
 145         GVariant *va = NULL;
 146         GVariantBuilder *builder = NULL;
 147         builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 148         g_variant_builder_add(builder, "{sv}", "Distance", g_variant_new_uint64(1));
 149         g_variant_builder_add(builder, "{sv}", "NodeID", g_variant_new_uint64(2));
 150         g_variant_builder_add(builder, "{sv}", "PanID", g_variant_new_uint16(3));
 151         g_variant_builder_add(builder, "{sv}", "X", g_variant_new_int32(4));
 152         g_variant_builder_add(builder, "{sv}", "Y", g_variant_new_int32(5));
 153         g_variant_builder_add(builder, "{sv}", "Z", g_variant_new_int32(6));
 154
 155         g_variant_builder_add(builder, "{sv}", "MODE", g_variant_new_string("ANCHOR"));
 156         g_variant_builder_add(builder, "{sv}", "NETWORK_TIMEOUT", g_variant_new_int64(1));
 157         g_variant_builder_add(builder, "{sv}", "HARDWARE_WAIT_TIME", g_variant_new_int64(1));
 158         g_variant_builder_add(builder, "{sv}", "PANID", g_variant_new_int64(1));
 159
 160         va = g_variant_builder_end(builder);
 161         g_variant_builder_unref(builder);
 162
 163         return va;
 164 }
 165
 166 int state;
 167 API gboolean g_variant_iter_loop(GVariantIter *iter, const gchar  *format_string, ...)
 168 {
 169         va_list ap;
 170         const gchar **key = NULL;
 171         char _key[1024] = {0,};
 172         GVariant **value = NULL;
 173         bool ret = true;
 174
 175         if (0 != strncmp(format_string, "{sv}", strlen(format_string)))
 176                 return false;
 177
 178         va_start(ap, format_string);
 179         key = va_arg(ap, const gchar **);
 180         value = va_arg(ap, GVariant **);
 181
 182         switch (state) {
 183                 case 0:
 184                         strncpy(_key, "Distance", sizeof(_key));
 185                         *value = g_variant_new_uint64(1);
 186                         break;
 187                 case 1:
 188                         strncpy(_key, "NodeID", sizeof(_key));
 189                         *value = g_variant_new_uint64(1);
 190                         break;
 191                 case 2:
 192                         strncpy(_key, "PanID", sizeof(_key));
 193                         *value = g_variant_new_uint16(1);
 194                         break;
 195                 case 3:
 196                         strncpy(_key, "X", sizeof(_key));
 197                         *value = g_variant_new_int32(1);
 198                         break;
 199                 case 4:
 200                         strncpy(_key, "Y", sizeof(_key));
 201                         *value = g_variant_new_int32(1);
 202                         break;
 203                 case 5:
 204                         strncpy(_key, "Z", sizeof(_key));
 205                         *value = g_variant_new_int32(1);
 206                         break;
 207                 default:
 208                         ret = false;
 209         }
 210
 211         if (ret == true) {
 212                 *key = (const gchar *)_key;
 213                 state += 1;
 214         } else {
 215                 state = 0;
 216         }
 217
 218         va_end(ap);
 219
 220         return ret;
 221 }
 222
 223 API void g_variant_get (GVariant *value, const gchar *format_string, ...)
 224 {
 225         va_list ap;
 226
 227         if (0 == strncmp(format_string, "(q@aa{sv})", strlen(format_string))) {
 228                 guint16 *out_pan_id;
 229                 GVariant **out_remote_node_list = NULL;
 230                 va_start(ap, format_string);
 231
 232                 out_pan_id = va_arg(ap, guint16 *);
 233                 *out_pan_id = 1;
 234
 235                 out_remote_node_list = va_arg(ap, GVariant **);
 236                 *out_remote_node_list = __create_dummy();
 237
 238                 va_end(ap);
 239         } else if (0 == strncmp(format_string, "(@a{sv})", strlen(format_string))) {
 240                 GVariant **out_own_node = NULL;
 241                 va_start(ap, format_string);
 242
 243                 out_own_node = va_arg(ap, GVariant **);
 244                 *out_own_node = __create_vardict();
 245
 246                 va_end(ap);
 247         }
 248 }
 249
 250 API gsize g_variant_n_children(GVariant *value)
 251 {
 252         return 0;
 253 }
 254
 255 API void g_variant_iter_free (GVariantIter *iter)
 256 {
 257         return;
 258 }