src/sensorctl/testcase/sensor_provider.cpp

   1 /*
   2  * sensorctl
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <unistd.h>
  21 #include <string.h>
  22 #include <sensor_internal.h>
  23 #include <sensor_utils.h>
  24
  25 #include "log.h"
  26 #include "mainloop.h"
  27 #include "test_bench.h"
  28
  29 #define MYSENSOR_URI "http://example.org/sensor/general/mysensor/mysensor"
  30 #define MYSENSOR_BATCH_URI "http://example.org/sensor/general/mysensor/mysensor-batch"
  31
  32 #define MYSENSOR_NAME "mysensor"
  33 #define MYSENSOR_BATCH_NAME "mysensor-batch"
  34 #define MYSENSOR_VENDOR "tizen"
  35
  36 #define NUMBER_OF_EVENT 100
  37
  38 static bool started = false;
  39 static bool added = false;
  40 static bool called = false;
  41
  42 static void event_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
  43 {
  44         _I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]);
  45 }
  46
  47 static void events_cb(sensor_t sensor, unsigned int event_type, sensor_data_t* datas[], int events_count, void *user_data)
  48 {
  49         for (int i = 0 ; i < events_count; i++) {
  50                 _I("[%llu]", datas[i]->timestamp);
  51                 for (int j = 0; j < datas[i]->value_count; j++)
  52                         _I(" %f", datas[i]->values[j]);
  53                 _I("\n");
  54         }
  55 }
  56
  57 static void start_cb(sensord_provider_h provider, void *user_data)
  58 {
  59         started = true;
  60         _N("START\n");
  61 }
  62
  63 static void stop_cb(sensord_provider_h provider, void *user_data)
  64 {
  65         started = false;
  66         _N("STOP\n");
  67 }
  68
  69 static void interval_cb(sensord_provider_h provider, unsigned int interval_ms, void *user_data)
  70 {
  71         _N("Interval : %d\n", interval_ms);
  72 }
  73
  74 static gboolean publish(gpointer gdata)
  75 {
  76         if (!started) return TRUE;
  77
  78         sensord_provider_h *provider = reinterpret_cast<sensord_provider_h *>(gdata);
  79
  80         sensor_data_t data;
  81         data.accuracy = 3;
  82         data.timestamp = sensor::utils::get_timestamp();
  83         data.value_count = 3;
  84         data.values[0] = 1;
  85         data.values[1] = 2;
  86         data.values[2] = 3;
  87
  88         _N("[%llu] %f %f %f\n", data.timestamp, data.values[0], data.values[1], data.values[2]);
  89         sensord_provider_publish(provider, data);
  90         return TRUE;
  91 }
  92
  93 static gboolean publish_batch_event(gpointer gdata)
  94 {
  95         if (!started) return FALSE;
  96
  97         sensord_provider_h *provider = reinterpret_cast<sensord_provider_h *>(gdata);
  98
  99         sensor_data_t data[NUMBER_OF_EVENT];
 100
 101         for (int i = 0 ; i < NUMBER_OF_EVENT; i++) {
 102                 data[i].accuracy = 3;
 103                 data[i].timestamp = sensor::utils::get_timestamp();
 104                 data[i].value_count = 3;
 105                 data[i].values[0] = i;
 106                 data[i].values[1] = i;
 107                 data[i].values[2] = i;
 108         }
 109         sensord_provider_publish_events(provider, data, NUMBER_OF_EVENT);
 110         _N("[ PUBLISH ] %d events\n", NUMBER_OF_EVENT);
 111         g_timeout_add_seconds(1, publish_batch_event, provider);
 112         return FALSE;
 113 }
 114
 115 static void add_mysensor(void)
 116 {
 117         sensord_provider_h provider;
 118
 119         sensord_create_provider(MYSENSOR_URI, &provider);
 120         sensord_provider_set_name(provider, MYSENSOR_NAME);
 121         sensord_provider_set_vendor(provider, MYSENSOR_VENDOR);
 122         sensord_provider_set_range(provider, 0.0f, 1.0f);
 123         sensord_provider_set_resolution(provider, 0.01f);
 124
 125         sensord_add_provider(provider);
 126
 127         sensord_remove_provider(provider);
 128         sensord_destroy_provider(provider);
 129 }
 130
 131 static void added_cb(const char *uri, void *user_data)
 132 {
 133         _I("[  ADDED  ] %s\n", uri);
 134         added = true;
 135 }
 136
 137 static void removed_cb(const char *uri, void *user_data)
 138 {
 139         _I("[ REMOVED ] %s\n", uri);
 140         if (added)
 141                 mainloop::stop();
 142 }
 143
 144 TESTCASE(sensor_provider, check_uri)
 145 {
 146         int err;
 147         sensord_provider_h provider;
 148
 149         const char *uri_p1 = "http://example.org/sensor/general/mysensor_type/mysensor";
 150         const char *uri_p2 = "http://developer.samsung.com/sensor/general/mysensor_type/mysensor";
 151         const char *uri_n1 = "http://tizen.org/sensor/general/accelerometer/mysensor";
 152         const char *uri_n2 = "http://tizen.org/mysensor/general/accelerometer/mysensor";
 153         const char *uri_n3 = "http:/example.org/sensor/general/mysensor_type/mysensor";
 154         const char *uri_n5 = "http://example.org/sensor/general/mysensor_type";
 155         const char *uri_n4 = "http://example.org/sensor/general/mysensor_type/mysensor/mysensor";
 156
 157         err = sensord_create_provider(uri_p1, &provider);
 158         EXPECT_EQ(err, 0);
 159         err = sensord_create_provider(uri_p2, &provider);
 160         EXPECT_EQ(err, 0);
 161         err = sensord_create_provider(uri_n1, &provider);
 162         EXPECT_EQ(err, -EINVAL);
 163         err = sensord_create_provider(uri_n2, &provider);
 164         EXPECT_EQ(err, -EINVAL);
 165         err = sensord_create_provider(uri_n3, &provider);
 166         EXPECT_EQ(err, -EINVAL);
 167         err = sensord_create_provider(uri_n4, &provider);
 168         EXPECT_EQ(err, -EINVAL);
 169         err = sensord_create_provider(uri_n5, &provider);
 170         EXPECT_EQ(err, -EINVAL);
 171
 172         return true;
 173 }
 174
 175 /* TODO: change it from manual test to auto-test */
 176 TESTCASE(skip_sensor_provider, mysensor_added_removed_cb_p_1)
 177 {
 178         int ret = sensord_add_sensor_added_cb(added_cb, NULL);
 179         ASSERT_EQ(ret, 0);
 180         ret = sensord_add_sensor_removed_cb(removed_cb, NULL);
 181         ASSERT_EQ(ret, 0);
 182
 183         add_mysensor();
 184
 185         mainloop::run();
 186
 187         ret = sensord_remove_sensor_added_cb(added_cb);
 188         ASSERT_EQ(ret, 0);
 189         ret = sensord_remove_sensor_removed_cb(removed_cb);
 190         ASSERT_EQ(ret, 0);
 191
 192         return true;
 193 }
 194
 195 /* TODO: change it from manual test to auto-test */
 196 TESTCASE(skip_sensor_provider, mysensor_p)
 197 {
 198         int err = 0;
 199         sensor_t sensor;
 200         sensord_provider_h provider;
 201
 202         err = sensord_create_provider(MYSENSOR_URI, &provider);
 203         ASSERT_EQ(err, 0);
 204
 205         err = sensord_provider_set_name(provider, MYSENSOR_NAME);
 206         ASSERT_EQ(err, 0);
 207         err = sensord_provider_set_vendor(provider, MYSENSOR_VENDOR);
 208         ASSERT_EQ(err, 0);
 209         err = sensord_provider_set_range(provider, 0.0f, 1.0f);
 210         ASSERT_EQ(err, 0);
 211         err = sensord_provider_set_resolution(provider, 0.01f);
 212         ASSERT_EQ(err, 0);
 213
 214         err = sensord_add_provider(provider);
 215         ASSERT_EQ(err, 0);
 216
 217         err = sensord_provider_set_start_cb(provider, start_cb, NULL);
 218         ASSERT_EQ(err, 0);
 219         err = sensord_provider_set_stop_cb(provider, stop_cb, NULL);
 220         ASSERT_EQ(err, 0);
 221         err = sensord_provider_set_interval_changed_cb(provider, interval_cb, NULL);
 222         ASSERT_EQ(err, 0);
 223
 224         err = sensord_get_default_sensor_by_uri(MYSENSOR_URI, &sensor);
 225         ASSERT_EQ(err, 0);
 226
 227         g_timeout_add_seconds(1, publish, provider);
 228         mainloop::run();
 229
 230         err = sensord_remove_provider(provider);
 231         ASSERT_EQ(err, 0);
 232         err = sensord_destroy_provider(provider);
 233         ASSERT_EQ(err, 0);
 234
 235         return true;
 236 }
 237
 238 /* TODO: change it from manual test to auto-test */
 239 TESTCASE(skip_sensor_provider, mysensor_with_listener_p_1)
 240 {
 241         int err;
 242         bool ret;
 243         int handle;
 244         sensor_t sensor;
 245
 246         called = false;
 247
 248         err = sensord_get_default_sensor_by_uri(MYSENSOR_URI, &sensor);
 249         ASSERT_EQ(err, 0);
 250
 251         handle = sensord_connect(sensor);
 252         ASSERT_EQ(err, 0);
 253
 254         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 255         ASSERT_TRUE(ret);
 256
 257         ret = sensord_start(handle, 0);
 258         ASSERT_TRUE(ret);
 259
 260         ret = sensord_change_event_interval(handle, 0, 100);
 261         ASSERT_TRUE(ret);
 262
 263         mainloop::run();
 264
 265         ret = sensord_stop(handle);
 266         ASSERT_TRUE(ret);
 267
 268         ret = sensord_unregister_event(handle, 1);
 269         ASSERT_TRUE(ret);
 270
 271         ret = sensord_disconnect(handle);
 272         ASSERT_TRUE(ret);
 273
 274         return true;
 275 }
 276
 277 /* TODO: change it from manual test to auto-test */
 278 TESTCASE(skip_sensor_provider, mysensor_batch_p)
 279 {
 280         int err = 0;
 281         sensor_t sensor;
 282         sensord_provider_h provider;
 283
 284         err = sensord_create_provider(MYSENSOR_BATCH_URI, &provider);
 285         ASSERT_EQ(err, 0);
 286
 287         err = sensord_provider_set_name(provider, MYSENSOR_BATCH_NAME);
 288         ASSERT_EQ(err, 0);
 289         err = sensord_provider_set_vendor(provider, MYSENSOR_VENDOR);
 290         ASSERT_EQ(err, 0);
 291         err = sensord_provider_set_range(provider, 0.0f, 1.0f);
 292         ASSERT_EQ(err, 0);
 293         err = sensord_provider_set_resolution(provider, 0.01f);
 294         ASSERT_EQ(err, 0);
 295
 296         err = sensord_add_provider(provider);
 297         ASSERT_EQ(err, 0);
 298
 299         err = sensord_provider_set_start_cb(provider, start_cb, NULL);
 300         ASSERT_EQ(err, 0);
 301         err = sensord_provider_set_stop_cb(provider, stop_cb, NULL);
 302         ASSERT_EQ(err, 0);
 303         err = sensord_provider_set_interval_changed_cb(provider, interval_cb, NULL);
 304         ASSERT_EQ(err, 0);
 305
 306         err = sensord_get_default_sensor_by_uri(MYSENSOR_BATCH_URI, &sensor);
 307         ASSERT_EQ(err, 0);
 308
 309         g_timeout_add_seconds(1, publish_batch_event, provider);
 310         mainloop::run();
 311
 312         err = sensord_remove_provider(provider);
 313         ASSERT_EQ(err, 0);
 314         err = sensord_destroy_provider(provider);
 315         ASSERT_EQ(err, 0);
 316
 317         return true;
 318 }
 319
 320
 321 /* TODO: change it from manual test to auto-test */
 322 TESTCASE(skip_sensor_provider, mysensor_batch_with_listener_p_1)
 323 {
 324         int err;
 325         bool ret;
 326         int handle;
 327         sensor_t sensor;
 328
 329         called = false;
 330
 331         err = sensord_get_default_sensor_by_uri(MYSENSOR_BATCH_URI, &sensor);
 332         ASSERT_EQ(err, 0);
 333
 334         handle = sensord_connect(sensor);
 335         ASSERT_EQ(err, 0);
 336
 337         ret = sensord_register_events(handle, 1, 100, events_cb, NULL);
 338         ASSERT_TRUE(ret);
 339
 340         ret = sensord_start(handle, 0);
 341         ASSERT_TRUE(ret);
 342
 343         ret = sensord_change_event_interval(handle, 0, 100);
 344         ASSERT_TRUE(ret);
 345
 346         mainloop::run();
 347
 348         ret = sensord_stop(handle);
 349         ASSERT_TRUE(ret);
 350
 351         ret = sensord_unregister_events(handle, 1);
 352         ASSERT_TRUE(ret);
 353
 354         ret = sensord_disconnect(handle);
 355         ASSERT_TRUE(ret);
 356
 357         return true;
 358 }