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_NAME "mysensor"
  31 #define MYSENSOR_VENDOR "tizen"
  32
  33 static bool started = false;
  34 static bool added = false;
  35 static bool called = false;
  36
  37 static void event_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
  38 {
  39         _I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]);
  40 }
  41
  42 static void start_cb(sensord_provider_h provider, void *user_data)
  43 {
  44         started = true;
  45         _N("START\n");
  46 }
  47
  48 static void stop_cb(sensord_provider_h provider, void *user_data)
  49 {
  50         started = false;
  51         _N("STOP\n");
  52 }
  53
  54 static void interval_cb(sensord_provider_h provider, unsigned int interval_ms, void *user_data)
  55 {
  56         _N("Interval : %d\n", interval_ms);
  57 }
  58
  59 static gboolean publish(gpointer gdata)
  60 {
  61         if (!started) return TRUE;
  62
  63         sensord_provider_h *provider = reinterpret_cast<sensord_provider_h *>(gdata);
  64
  65         sensor_data_t data;
  66         data.accuracy = 3;
  67         data.timestamp = sensor::utils::get_timestamp();
  68         data.value_count = 3;
  69         data.values[0] = 1;
  70         data.values[1] = 2;
  71         data.values[2] = 3;
  72
  73         _N("[%llu] %f %f %f\n", data.timestamp, data.values[0], data.values[1], data.values[2]);
  74         sensord_provider_publish(provider, data);
  75         return TRUE;
  76 }
  77
  78 static void add_mysensor(void)
  79 {
  80         sensord_provider_h provider;
  81
  82         sensord_create_provider(MYSENSOR_URI, &provider);
  83         sensord_provider_set_name(provider, MYSENSOR_NAME);
  84         sensord_provider_set_vendor(provider, MYSENSOR_VENDOR);
  85         sensord_provider_set_range(provider, 0.0f, 1.0f);
  86         sensord_provider_set_resolution(provider, 0.01f);
  87
  88         sensord_add_provider(provider);
  89         sensord_remove_provider(provider);
  90
  91         sensord_destroy_provider(provider);
  92 }
  93
  94 static void added_cb(const char *uri, void *user_data)
  95 {
  96         _I("[  ADDED  ] %s\n", uri);
  97         added = true;
  98 }
  99
 100 static void removed_cb(const char *uri, void *user_data)
 101 {
 102         _I("[ REMOVED ] %s\n", uri);
 103         if (added)
 104                 mainloop::stop();
 105 }
 106
 107 TESTCASE(sensor_provider, check_uri)
 108 {
 109         int err;
 110         sensord_provider_h provider;
 111
 112         const char *uri_p1 = "http://example.org/sensor/general/mysensor_type/mysensor";
 113         const char *uri_p2 = "http://developer.samsung.com/sensor/general/mysensor_type/mysensor";
 114         const char *uri_n1 = "http://tizen.org/sensor/general/accelerometer/mysensor";
 115         const char *uri_n2 = "http://tizen.org/mysensor/general/accelerometer/mysensor";
 116         const char *uri_n3 = "http:/example.org/sensor/general/mysensor_type/mysensor";
 117         const char *uri_n5 = "http://example.org/sensor/general/mysensor_type";
 118         const char *uri_n4 = "http://example.org/sensor/general/mysensor_type/mysensor/mysensor";
 119
 120         err = sensord_create_provider(uri_p1, &provider);
 121         EXPECT_EQ(err, 0);
 122         err = sensord_create_provider(uri_p2, &provider);
 123         EXPECT_EQ(err, 0);
 124         err = sensord_create_provider(uri_n1, &provider);
 125         EXPECT_EQ(err, -EINVAL);
 126         err = sensord_create_provider(uri_n2, &provider);
 127         EXPECT_EQ(err, -EINVAL);
 128         err = sensord_create_provider(uri_n3, &provider);
 129         EXPECT_EQ(err, -EINVAL);
 130         err = sensord_create_provider(uri_n4, &provider);
 131         EXPECT_EQ(err, -EINVAL);
 132         err = sensord_create_provider(uri_n5, &provider);
 133         EXPECT_EQ(err, -EINVAL);
 134
 135         return true;
 136 }
 137
 138 /* TODO: change it from manual test to auto-test */
 139 TESTCASE(skip_sensor_provider, mysensor_added_removed_cb_p_1)
 140 {
 141         int ret = sensord_add_sensor_added_cb(added_cb, NULL);
 142         ASSERT_EQ(ret, 0);
 143         ret = sensord_add_sensor_removed_cb(removed_cb, NULL);
 144         ASSERT_EQ(ret, 0);
 145
 146         add_mysensor();
 147
 148         mainloop::run();
 149
 150         ret = sensord_remove_sensor_added_cb(added_cb);
 151         ASSERT_EQ(ret, 0);
 152         ret = sensord_remove_sensor_removed_cb(removed_cb);
 153         ASSERT_EQ(ret, 0);
 154
 155         return true;
 156 }
 157
 158 /* TODO: change it from manual test to auto-test */
 159 TESTCASE(skip_sensor_provider, mysensor_p)
 160 {
 161         int err = 0;
 162         sensor_t sensor;
 163         sensord_provider_h provider;
 164
 165         err = sensord_create_provider(MYSENSOR_URI, &provider);
 166         ASSERT_EQ(err, 0);
 167
 168         err = sensord_provider_set_name(provider, MYSENSOR_NAME);
 169         ASSERT_EQ(err, 0);
 170         err = sensord_provider_set_vendor(provider, MYSENSOR_VENDOR);
 171         ASSERT_EQ(err, 0);
 172         err = sensord_provider_set_range(provider, 0.0f, 1.0f);
 173         ASSERT_EQ(err, 0);
 174         err = sensord_provider_set_resolution(provider, 0.01f);
 175         ASSERT_EQ(err, 0);
 176
 177         err = sensord_add_provider(provider);
 178         ASSERT_EQ(err, 0);
 179
 180         err = sensord_provider_set_start_cb(provider, start_cb, NULL);
 181         ASSERT_EQ(err, 0);
 182         err = sensord_provider_set_stop_cb(provider, stop_cb, NULL);
 183         ASSERT_EQ(err, 0);
 184         err = sensord_provider_set_interval_changed_cb(provider, interval_cb, NULL);
 185         ASSERT_EQ(err, 0);
 186
 187         err = sensord_get_default_sensor_by_uri(MYSENSOR_URI, &sensor);
 188         ASSERT_EQ(err, 0);
 189
 190         g_timeout_add_seconds(1, publish, provider);
 191         mainloop::run();
 192
 193         err = sensord_remove_provider(provider);
 194         ASSERT_EQ(err, 0);
 195         err = sensord_destroy_provider(provider);
 196         ASSERT_EQ(err, 0);
 197
 198         return true;
 199 }
 200
 201 /* TODO: change it from manual test to auto-test */
 202 TESTCASE(skip_sensor_provider, mysensor_with_listener_p_1)
 203 {
 204         int err;
 205         bool ret;
 206         int handle;
 207         sensor_t sensor;
 208
 209         called = false;
 210
 211         err = sensord_get_default_sensor_by_uri(MYSENSOR_URI, &sensor);
 212         ASSERT_EQ(err, 0);
 213
 214         handle = sensord_connect(sensor);
 215         ASSERT_EQ(err, 0);
 216
 217         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 218         ASSERT_TRUE(ret);
 219
 220         ret = sensord_start(handle, 0);
 221         ASSERT_TRUE(ret);
 222
 223         ret = sensord_change_event_interval(handle, 0, 100);
 224         ASSERT_TRUE(ret);
 225
 226         mainloop::run();
 227
 228         ret = sensord_stop(handle);
 229         ASSERT_TRUE(ret);
 230
 231         ret = sensord_unregister_event(handle, 1);
 232         ASSERT_TRUE(ret);
 233
 234         ret = sensord_disconnect(handle);
 235         ASSERT_TRUE(ret);
 236
 237         return true;
 238 }
 239