#include "test_bench.h"
#include "sensor_adapter.h"
-static void basic_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
+static void test_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
{
EXPECT_GT(data->timestamp, 0);
EXPECT_NEAR(data->values[0], 0, 19.6);
mainloop::stop();
}
-TESTCASE(accelerometer_basic, start_stop_p)
+TESTCASE(accelerometer_test, start_stop_p)
{
bool ret;
int handle;
+ if (!sensor_adapter::is_supported(ACCELEROMETER_SENSOR))
+ return true; /* Not Supported */
+
sensor_info info(ACCELEROMETER_SENSOR, 0,
- 100, 1000, SENSOR_OPTION_ALWAYS_ON, basic_cb, NULL);
+ 100, 1000, SENSOR_OPTION_ALWAYS_ON, test_cb, NULL);
ret = sensor_adapter::start(info, handle);
ASSERT_TRUE(ret);
mainloop::stop();
}
-TESTCASE(accelerometer_basic, get_data_p)
+TESTCASE(accelerometer_test, get_data_p)
{
bool ret;
int handle;
sensor_data_t data;
+ if (!sensor_adapter::is_supported(ACCELEROMETER_SENSOR))
+ return true; /* Not Supported */
+
sensor_info info(ACCELEROMETER_SENSOR, 0,
100, 1000, SENSOR_OPTION_ALWAYS_ON, get_data_cb, NULL);
return true;
}
-static unsigned long long prev_prev_ts;
-static unsigned long long prev_ts;
+static unsigned long long time_first;
+static unsigned long long time_last;
static int event_count;
-static void accel_regular_interval_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
+static void accel_interval_100ms_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
{
- int prev_gap;
- int current_gap;
- if (prev_prev_ts == 0) {
- prev_prev_ts = data->timestamp;
+ if (event_count == 0) {
+ time_first = data->timestamp;
+ event_count++;
return;
}
- if (prev_ts == 0) {
- prev_ts = data->timestamp;
- return;
- }
-
- prev_gap = prev_ts - prev_prev_ts;
- current_gap = data->timestamp - prev_ts;
-
- EXPECT_NEAR(current_gap, prev_gap, 10000);
- prev_prev_ts = prev_ts;
- prev_ts = data->timestamp;
-
- if (event_count++ > 3)
+ if (event_count == 10) {
+ /* 100ms + 20ms(error) */
+ EXPECT_LE((data->timestamp - time_first) / 10, 120000);
mainloop::stop();
-}
-
-TESTCASE(accelerometer_interval, regular_interval_p)
-{
- bool ret;
- int handle;
- prev_prev_ts = 0;
- prev_ts = 0;
- event_count = 0;
-
- sensor_info info(ACCELEROMETER_SENSOR, 0,
- 100, 1000, SENSOR_OPTION_ALWAYS_ON, accel_regular_interval_cb, NULL);
-
- ret = sensor_adapter::start(info, handle);
- ASSERT_TRUE(ret);
-
- mainloop::run();
-
- ret = sensor_adapter::stop(info, handle);
- ASSERT_TRUE(ret);
-
- return true;
-}
-
-static void accel_interval_100ms_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
-{
- if (prev_ts == 0) {
- prev_ts = data->timestamp;
return;
}
- /* 100ms + 20ms(error) */
- EXPECT_LE(data->timestamp - prev_ts, 120000);
- prev_ts = data->timestamp;
-
- if (event_count++ > 3)
- mainloop::stop();
+ event_count++;
}
-TESTCASE(accelerometer_interval, 100ms_interval_p)
+TESTCASE(accelscope_test, 100ms_interval_p)
{
bool ret;
int handle;
- prev_ts = 0;
+ time_first = 0;
+ time_last = 0;
event_count = 0;
+ if (!sensor_adapter::is_supported(ACCELEROMETER_SENSOR))
+ return true; /* Not Supported */
+
sensor_info info(ACCELEROMETER_SENSOR, 0,
100, 1000, SENSOR_OPTION_ALWAYS_ON, accel_interval_100ms_cb, NULL);
*/
#include <unistd.h>
+#include <string.h>
#include <sensor_internal.h>
#include "log.h"
#include "test_bench.h"
#include "sensor_adapter.h"
+/* exception list */
+#define SAMSUNG_PEDOMETER "http://samsung.com/sensor/healthinfo/pedometer/samsung_pedometer"
+
static void basic_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
{
EXPECT_GT(data->timestamp, 0);
- //_N("[ DATA ] %f\n", data->values[0]);
+ _N(_WHT "[ DATA ] %f\n" _RST, data->values[0]);
mainloop::stop();
}
-TESTCASE(all_sensor_test, scenario_basic_p)
+static bool skip_sensor(sensor_t sensor)
+{
+ const char *uri = sensord_get_uri(sensor);
+
+ if (strncmp(uri, SAMSUNG_PEDOMETER, sizeof(SAMSUNG_PEDOMETER)) == 0)
+ return true;
+
+ return false;
+}
+
+TESTCASE(sensor_basic, all_sensor_p)
{
- int err;
+ int err, count, handle;
bool ret;
- int count;
- int handle;
sensor_t *sensors;
sensor_type_t type;
ASSERT_EQ(err, 0);
for (int i = 0; i < count; ++i) {
- sensord_get_type(sensors[i], &type);
- /* TODO */
- _N("[ TYPE ] %s\n", "UNKNOWN_SENSOR");
+ if (skip_sensor(sensors[i]))
+ continue;
+
+ _W("[ SENSOR %d ] %s\n", i, sensord_get_uri(sensors[i]));
+ sensord_get_type(sensors[i], &type);
sensor_info info(type, 0, 100, 1000, SENSOR_OPTION_ALWAYS_ON, basic_cb, NULL);
ret = sensor_adapter::start(info, handle);
return true;
}
-
-typedef bool (*process_func_t)(const char *msg, int size, int count);
-
-static pid_t run_process(process_func_t func, const char *msg, int size, int count)
-{
- pid_t pid = fork();
- if (pid < 0)
- return -1;
-
- if (pid == 0) {
- if (!func(msg, size, count))
- _E("Failed to run process\n");
- exit(0);
- }
-
- return pid;
-}
-
-static bool run_echo_command_test(const char *str, int size, int cout)
-{
- bool ret = true;
- int handle;
- char buf[4096] = {'1', '1', '1', };
-
- sensor_info info(ACCELEROMETER_SENSOR, 0,
- 100, 1000, SENSOR_OPTION_ALWAYS_ON, basic_cb, NULL);
- sensor_adapter::get_handle(info, handle);
-
- for (int i = 0; i < 1024; ++i)
- ret &= sensor_adapter::set_attribute(handle, SENSOR_ATTR_ACCELEROMETER_INJECTION, buf, 4096);
- ASSERT_TRUE(ret);
-
- return true;
-}
-
-TESTCASE(echo_command_test, echo_command_p)
-{
- pid_t pid;
-
- for (int i = 0; i < 100; ++i) {
- pid = run_process(run_echo_command_test, NULL, 0, 0);
- EXPECT_GE(pid, 0);
- }
-
- pid = run_process(run_echo_command_test, NULL, 0, 0);
- EXPECT_GE(pid, 0);
-
- ASSERT_TRUE(true);
-
- return true;
-}
-
-#if 0
-TESTCASE(gyroscope_value_p)
-{
- scenario_basic_p(GYROSCOPE_SENSOR);
-}
-
-TESTCASE(gravitye_value_p)
-{
- scenario_basic_p(GRAVITY_SENSOR);
-}
-
-TESTCASE(linear_accel_value_p)
-{
- scenario_basic_p(LINEAR_ACCEL_SENSOR);
-}
-
-TESTCASE(proximity_value_p)
-{
- scenario_basic_p(PROXIMITY_SENSOR);
-}
-
-TESTCASE(pressure_value_p)
-{
- scenario_basic_p(PRESSURE_SENSOR);
-}
-
-TESTCASE(hrm_value_p)
-{
- scenario_basic_p(HRM_SENSOR);
-}
-
-TESTCASE(hrm_raw_value_p)
-{
- scenario_basic_p(HRM_RAW_SENSOR);
-}
-
-TESTCASE(hrm_led_green_value_p)
-{
- scenario_basic_p(HRM_LED_GREEN_SENSOR);
-}
-
-TESTCASE(wrist_up_value_p)
-{
- scenario_basic_p(GESTURE_WRIST_UP_SENSOR);
-}
-#endif
*
*/
+#include <unistd.h>
+#include <sensor_internal.h>
+
+#include "log.h"
+#include "mainloop.h"
#include "test_bench.h"
+#include "sensor_adapter.h"
-TESTCASE(sensor_interval, all_sensor_interval_10ms_p)
+static void basic_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
{
- /* TODO: test 10ms interval */
+ EXPECT_GT(data->timestamp, 0);
+ mainloop::stop();
+}
+
+TESTCASE(interval_test, 20ms_p)
+{
+ int err, count, handle;
+ bool ret;
+ sensor_t *sensors;
+ sensor_type_t type;
+
+ err = sensord_get_sensors(ACCELEROMETER_SENSOR, &sensors, &count);
+ ASSERT_EQ(err, 0);
+
+ for (int i = 0; i < count; ++i) {
+ sensord_get_type(sensors[i], &type);
+ sensor_info info(type, 0, 20, 1000, SENSOR_OPTION_ALWAYS_ON, basic_cb, NULL);
+
+ ret = sensor_adapter::start(info, handle);
+ EXPECT_TRUE(ret);
+
+ mainloop::run();
+
+ ret = sensor_adapter::stop(info, handle);
+ EXPECT_TRUE(ret);
+ }
+
+ free(sensors);
+
+ return true;
+}
+
+TESTCASE(interval_test, 100ms_p)
+{
+ int err, count, handle;
+ bool ret;
+ sensor_t *sensors;
+ sensor_type_t type;
+
+ err = sensord_get_sensors(ACCELEROMETER_SENSOR, &sensors, &count);
+ ASSERT_EQ(err, 0);
+
+ for (int i = 0; i < count; ++i) {
+ sensord_get_type(sensors[i], &type);
+ sensor_info info(type, 0, 100, 1000, SENSOR_OPTION_ALWAYS_ON, basic_cb, NULL);
+
+ ret = sensor_adapter::start(info, handle);
+ EXPECT_TRUE(ret);
+
+ mainloop::run();
+
+ ret = sensor_adapter::stop(info, handle);
+ EXPECT_TRUE(ret);
+ }
+
+ free(sensors);
+
+ return true;
+}
+
+TESTCASE(interval_test, 200ms_p)
+{
+ int err, count, handle;
+ bool ret;
+ sensor_t *sensors;
+ sensor_type_t type;
+
+ err = sensord_get_sensors(ACCELEROMETER_SENSOR, &sensors, &count);
+ ASSERT_EQ(err, 0);
+
+ for (int i = 0; i < count; ++i) {
+ sensord_get_type(sensors[i], &type);
+ sensor_info info(type, 0, 200, 1000, SENSOR_OPTION_ALWAYS_ON, basic_cb, NULL);
+
+ ret = sensor_adapter::start(info, handle);
+ EXPECT_TRUE(ret);
+
+ mainloop::run();
+
+ ret = sensor_adapter::stop(info, handle);
+ EXPECT_TRUE(ret);
+ }
+
+ free(sensors);
+
return true;
}
#include "test_bench.h"
static bool called = false;
+static int count = 0;
static void event_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
{
_I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]);
+
+ if (count++ > 3)
+ mainloop::stop();
}
-TESTCASE(sensor_api_get_default_sensor, get_sensor_p_1)
+TESTCASE(sensor_listener, get_default_sensor_p_1)
{
int err;
sensor_t sensor;
return true;
}
-TESTCASE(sensor_api_get_sensors, get_sensor_p_2)
+TESTCASE(sensor_listener, get_sensors_p_1)
{
int err;
int count;
return true;
}
-TESTCASE(sensor_api_connect, connect_p_1)
+TESTCASE(sensor_listener, connect_p_1)
{
int err;
int handle;
return true;
}
-TESTCASE(sensor_api_all, all_p_1)
+TESTCASE(sensor_listener, all_api_p_1)
{
int err;
bool ret;
return true;
}
+
+TESTCASE(sensor_listener, bad_unregister_stop_order_p_1)
+{
+ int err;
+ bool ret;
+ int handle;
+ sensor_t sensor;
+
+ called = false;
+
+ err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+ ASSERT_EQ(err, 0);
+
+ handle = sensord_connect(sensor);
+ ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
+ ret = sensord_start(handle, 0);
+ ret = sensord_change_event_interval(handle, 0, 100);
+
+ mainloop::run();
+
+ /* [TEST] Unregister event before stop */
+ ret = sensord_unregister_event(handle, 1);
+ ASSERT_TRUE(ret);
+
+ ret = sensord_stop(handle);
+ ASSERT_TRUE(ret);
+
+ ret = sensord_disconnect(handle);
+ ASSERT_TRUE(ret);
+
+ return true;
+}
+
+TESTCASE(sensor_listener, bad_disconnect_p_1)
+{
+ int err;
+ bool ret;
+ int handle;
+ sensor_t sensor;
+
+ called = false;
+
+ err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+ ASSERT_EQ(err, 0);
+
+ handle = sensord_connect(sensor);
+ ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
+ ret = sensord_start(handle, 0);
+ ret = sensord_change_event_interval(handle, 0, 100);
+
+ mainloop::run();
+
+ /* [TEST] Unregistering event is not called */
+
+ ret = sensord_stop(handle);
+ ASSERT_TRUE(ret);
+
+ ret = sensord_disconnect(handle);
+ ASSERT_TRUE(ret);
+
+ return true;
+}
+
+TESTCASE(sensor_listener, bad_disconnect_p_2)
+{
+ int err;
+ bool ret;
+ int handle;
+ sensor_t sensor;
+
+ called = false;
+
+ err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+ ASSERT_EQ(err, 0);
+
+ handle = sensord_connect(sensor);
+ ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
+ ret = sensord_start(handle, 0);
+ ret = sensord_change_event_interval(handle, 0, 100);
+
+ mainloop::run();
+
+ ret = sensord_unregister_event(handle, 1);
+ ASSERT_TRUE(ret);
+
+ /* [TEST] stopping sensor is not called */
+
+ ret = sensord_disconnect(handle);
+ ASSERT_TRUE(ret);
+
+ return true;
+}
static void event_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
{
- if (test_option::full_log == false) {
- while (true) {}
- }
_I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]);
}
mainloop::stop();
}
-TESTCASE(sensor_api_provider_uri, provider_check_uri)
+TESTCASE(sensor_provider, check_uri)
{
int err;
sensord_provider_h provider;
}
/* TODO: change it from manual test to auto-test */
-TESTCASE(sensor_api_provider_mysensor, provider_p_1)
+TESTCASE(skip_sensor_provider, mysensor_added_removed_cb_p_1)
+{
+ int ret = sensord_add_sensor_added_cb(added_cb, NULL);
+ ASSERT_EQ(ret, 0);
+ ret = sensord_add_sensor_removed_cb(removed_cb, NULL);
+ ASSERT_EQ(ret, 0);
+
+ add_mysensor();
+
+ mainloop::run();
+
+ ret = sensord_remove_sensor_added_cb(added_cb);
+ ASSERT_EQ(ret, 0);
+ ret = sensord_remove_sensor_removed_cb(removed_cb);
+ ASSERT_EQ(ret, 0);
+
+ return true;
+}
+
+/* TODO: change it from manual test to auto-test */
+TESTCASE(skip_sensor_provider, mysensor_p)
{
int err = 0;
sensor_t sensor;
return true;
}
-TESTCASE(sensor_api_listener_mysensor, listener_p_1)
+/* TODO: change it from manual test to auto-test */
+TESTCASE(skip_sensor_provider, mysensor_with_listener_p_1)
{
int err;
bool ret;
return true;
}
-TESTCASE(sensor_api_provider_cb, mysensor_cb_p_1)
-{
- int ret;
-
- ret = sensord_add_sensor_added_cb(added_cb, NULL);
- ASSERT_EQ(ret, 0);
- ret = sensord_add_sensor_removed_cb(removed_cb, NULL);
- ASSERT_EQ(ret, 0);
-
- add_mysensor();
-
- mainloop::run();
-
- ret = sensord_remove_sensor_added_cb(added_cb);
- ASSERT_EQ(ret, 0);
- ret = sensord_remove_sensor_removed_cb(removed_cb);
- ASSERT_EQ(ret, 0);
-
- return true;
-}
};
/* IPC Client Sleep Test(4096Kb * 1024) */
-static bool run_ipc_client_sleep_10s(const char *str, int size, int count)
+static bool run_ipc_client_sleep_1s(const char *str, int size, int count)
{
ipc_client client(TEST_PATH);
test_client_handler_30_1M client_handler;
}
/**
- * @brief Test 3 client + 1 client which sleeps 10 seconds
+ * @brief Test 3 client + 1 client which sleeps 1 seconds
*/
-TESTCASE(sensor_ipc_client_sleep_1s, sleep_1s_p)
+TESTCASE(sensor_ipc, 3_client_with_1s_sleep_client_p)
{
pid_t pid = run_process(run_ipc_server_echo, NULL, 0, 0);
EXPECT_GE(pid, 0);
EXPECT_GE(pid, 0);
}
- bool ret = run_ipc_client_sleep_10s(NULL, 0, 0);
+ bool ret = run_ipc_client_sleep_1s(NULL, 0, 0);
ASSERT_TRUE(ret);
SLEEP_1S;
}
/**
- * @brief Test 3 client + 1 client which has small recv buffer
+ * @brief Test 3 client + 1 client which has small recv buffer(2240)
*/
-TESTCASE(sensor_ipc_client_small_2240, ipc_client_small_2240_p)
+TESTCASE(sensor_ipc, 3_client_with_small_buffer_client_p)
{
pid_t pid = run_process(run_ipc_server_echo, NULL, 0, 0);
EXPECT_GE(pid, 0);
/**
* @brief Test 30 ipc_client with 1M message
*/
-TESTCASE(sensor_ipc_30_client_1M, ipc_client_p_30_1M)
+TESTCASE(sensor_ipc, 30_client_with_1M_message_p)
{
pid_t pid = run_process(run_ipc_server_echo, NULL, 0, 0);
EXPECT_GE(pid, 0);
/**
* @brief Test 2 channel of 1 client with message
*/
-TESTCASE(sensor_ipc_client_2_channel_message, 2_channel_message_p)
+TESTCASE(sensor_ipc, 1_client_with_2_channel_message_p)
{
pid_t pid = run_process(run_ipc_server, NULL, 0, 0);
EXPECT_GE(pid, 0);
/**
* @brief Test 2 channel of 1 client
*/
-TESTCASE(sensor_ipc_client_2_channel, 2_channel_p)
+TESTCASE(sensor_ipc, 1_client_2_channel_simple_p)
{
pid_t pid = run_process(run_ipc_server, NULL, 0, 0);
EXPECT_GE(pid, 0);
/**
* @brief Test 100 ipc_client
*/
-TESTCASE(sensor_ipc_100_client, ipc_client_p_100)
+TESTCASE(sensor_ipc, 100_client_p)
{
pid_t pid = run_process(run_ipc_server, NULL, 0, 0);
EXPECT_GE(pid, 0);
/**
* @brief Test 2 ipc_client
*/
-TESTCASE(sensor_ipc_2_client, ipc_client_p_2)
+TESTCASE(sensor_ipc, 2_client_p)
{
pid_t pid = run_process(run_ipc_server, NULL, 0, 0);
EXPECT_GE(pid, 0);
* 2. send "TEST" message from client to server
* 3. check that message in server handler
*/
-TESTCASE(sensor_ipc_client_0, ipc_client_p_0)
+TESTCASE(sensor_ipc, server_client_basic_p)
{
pid_t pid = run_process(run_ipc_server, NULL, 0, 0);
EXPECT_GE(pid, 0);
#include "log.h"
#include "test_bench.h"
-using namespace ipc;
-
#define MAX_BUF_SIZE 4096
#define TEST_PATH "/run/.sensord_test.socket"
+using namespace ipc;
+
typedef bool (*process_func_t)(const char *msg, int size, int count);
static pid_t run_process(process_func_t func, const char *msg, int size, int count)
accept_sock.set_blocking_mode(true);
accept_sock.bind();
accept_sock.listen(10);
- accept_sock.accept(client_sock);
+
+ while (!ret)
+ ret = accept_sock.accept(client_sock);
/* receive message */
while (recv_count++ < count) {
ASSERT_EQ(ret, 0);
sock.close();
-
return true;
}
* 3. check "TEST" message
* @remarks we can test only regular socket, not systemd-based socket.
*/
-TESTCASE(sensor_ipc_socket, socket_p_0)
+TESTCASE(ipc_socket, socket_simple_message_p)
{
const char *msg = "TEST";
int size = 4;
* 3. check total size
* @remarks we can test only regular socket, not systemd-based socket.
*/
-TESTCASE(sensor_ipc_socket, socket_p_10)
+TESTCASE(ipc_socket, socket_40K_message_p)
{
const char msg[MAX_BUF_SIZE] = {1, };
int size = MAX_BUF_SIZE;
* 3. check total size
* @remarks we can test only regular socket, not systemd-based socket.
*/
-TESTCASE(sensor_ipc_socket, socket_p_1000)
+TESTCASE(ipc_socket, socket_4M_message_p)
{
const char msg[MAX_BUF_SIZE] = {1, };
int size = MAX_BUF_SIZE;
projects / platform / core / system / sensord.git / commitdiff