src/sensorctl/testcase/sensor_listener.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 <client/sensor_manager.h>
  26 #include <client/sensor_listener.h>
  27
  28 #include "log.h"
  29 #include "mainloop.h"
  30 #include "test_bench.h"
  31
  32 static bool called = false;
  33 static int count = 0;
  34
  35 static void event_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
  36 {
  37         _I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]);
  38
  39         if (count++ > 3)
  40                 mainloop::stop();
  41 }
  42
  43 TESTCASE(sensor_listener, get_default_sensor_p_1)
  44 {
  45         int err;
  46         sensor_t sensor;
  47
  48         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
  49         ASSERT_EQ(err, 0);
  50
  51         return true;
  52 }
  53
  54 TESTCASE(sensor_listener, get_sensors_p_1)
  55 {
  56         int err;
  57         int count;
  58         sensor_t *sensors;
  59
  60         err = sensord_get_sensors(ACCELEROMETER_SENSOR, &sensors, &count);
  61         ASSERT_EQ(err, 0);
  62         ASSERT_GT(count, 0);
  63
  64         free(sensors);
  65
  66         return true;
  67 }
  68
  69 TESTCASE(sensor_listener, connect_p_1)
  70 {
  71         int err;
  72         int handle;
  73         sensor_t sensor;
  74
  75         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
  76         ASSERT_EQ(err, 0);
  77
  78         handle = sensord_connect(sensor);
  79         ASSERT_GT(handle, 0);
  80
  81         err = sensord_disconnect(handle);
  82         ASSERT_EQ(err, 1);
  83
  84         return true;
  85 }
  86
  87 TESTCASE(sensor_listener, all_api_p_1)
  88 {
  89         int err;
  90         bool ret;
  91         int handle;
  92         sensor_t sensor;
  93         sensor_t *list;
  94         int count;
  95
  96         called = false;
  97
  98         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
  99         ASSERT_EQ(err, 0);
 100
 101         err = sensord_get_sensors(ALL_SENSOR, &list, &count);
 102         ASSERT_EQ(err, 0);
 103
 104         handle = sensord_connect(sensor);
 105         ASSERT_EQ(err, 0);
 106
 107         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 108         ASSERT_TRUE(ret);
 109
 110         ret = sensord_start(handle, 0);
 111         ASSERT_TRUE(ret);
 112
 113         ret = sensord_change_event_interval(handle, 0, 100);
 114         ASSERT_TRUE(ret);
 115
 116         ret = sensord_change_event_max_batch_latency(handle, 0, 100);
 117         ASSERT_TRUE(ret);
 118
 119         mainloop::run();
 120
 121         ret = sensord_stop(handle);
 122         ASSERT_TRUE(ret);
 123
 124         ret = sensord_unregister_event(handle, 1);
 125         ASSERT_TRUE(ret);
 126
 127         ret = sensord_disconnect(handle);
 128         ASSERT_TRUE(ret);
 129
 130         free(list);
 131
 132         return true;
 133 }
 134
 135 TESTCASE(sensor_listener, bad_unregister_stop_order_p_1)
 136 {
 137         int err;
 138         bool ret;
 139         int handle;
 140         sensor_t sensor;
 141
 142         called = false;
 143
 144         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 145         ASSERT_EQ(err, 0);
 146
 147         handle = sensord_connect(sensor);
 148         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 149         ret = sensord_start(handle, 0);
 150         ret = sensord_change_event_interval(handle, 0, 100);
 151
 152         mainloop::run();
 153
 154         /* [TEST] Unregister event before stop */
 155         ret = sensord_unregister_event(handle, 1);
 156         ASSERT_TRUE(ret);
 157
 158         ret = sensord_stop(handle);
 159         ASSERT_TRUE(ret);
 160
 161         ret = sensord_disconnect(handle);
 162         ASSERT_TRUE(ret);
 163
 164         return true;
 165 }
 166
 167 TESTCASE(sensor_listener, bad_disconnect_p_1)
 168 {
 169         int err;
 170         bool ret;
 171         int handle;
 172         sensor_t sensor;
 173
 174         called = false;
 175
 176         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 177         ASSERT_EQ(err, 0);
 178
 179         handle = sensord_connect(sensor);
 180         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 181         ret = sensord_start(handle, 0);
 182         ret = sensord_change_event_interval(handle, 0, 100);
 183
 184         mainloop::run();
 185
 186         /* [TEST] Unregistering event is not called */
 187
 188         ret = sensord_stop(handle);
 189         ASSERT_TRUE(ret);
 190
 191         ret = sensord_disconnect(handle);
 192         ASSERT_TRUE(ret);
 193
 194         return true;
 195 }
 196
 197 TESTCASE(sensor_listener, bad_disconnect_p_2)
 198 {
 199         int err;
 200         bool ret;
 201         int handle;
 202         sensor_t sensor;
 203
 204         called = false;
 205
 206         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 207         ASSERT_EQ(err, 0);
 208
 209         handle = sensord_connect(sensor);
 210         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 211         ret = sensord_start(handle, 0);
 212         ret = sensord_change_event_interval(handle, 0, 100);
 213
 214         mainloop::run();
 215
 216         ret = sensord_unregister_event(handle, 1);
 217         ASSERT_TRUE(ret);
 218
 219         /* [TEST] stopping sensor is not called */
 220
 221         ret = sensord_disconnect(handle);
 222         ASSERT_TRUE(ret);
 223
 224         return true;
 225 }