From: srinivasa.m Date: Fri, 10 Aug 2018 12:48:48 +0000 (+0530) Subject: [Non-ACR]Adding HAL test for Sensor TM1 FW X-Git-Tag: submit/tizen/20210607.085043~11 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a38392fb8a8713c7a4a65603578e9cbf1971e449;p=platform%2Fhal%2Fbackend%2Ftm1%2Fsensor-tm1.git [Non-ACR]Adding HAL test for Sensor TM1 FW Change-Id: I62c022859485a8d70c80f75b1654bd59ff77840e Signed-off-by: srinivasa.m --- diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100644 new mode 100755 index bfaf9c1..26996b4 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,3 +48,5 @@ ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS}) TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${HAL_PKGS_LDFLAGS}) INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR}/sensor) + +ADD_SUBDIRECTORY(testcase) diff --git a/packaging/sensor-hal-tm1.spec b/packaging/sensor-hal-tm1.spec old mode 100644 new mode 100755 index d7f99b9..a0b89d0 --- a/packaging/sensor-hal-tm1.spec +++ b/packaging/sensor-hal-tm1.spec @@ -10,11 +10,22 @@ Source1: 99-sensor.rules ExcludeArch: aarch64 %ix86 x86_64 BuildRequires: cmake +BuildRequires: pkgconfig(vconf) BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(gio-2.0) +BuildRequires: pkgconfig(gmock) BuildRequires: sensor-hal-devel %description TM1 Sensor HAL +%package haltests +Summary: Device HAL(Hardware Abstraction Layer) Test Cases +Requires: %{name} = %{version}-%{release} + + +%description haltests +Sensor Device HAL(Hardware Abstraction Layer) Test Cases %prep %setup -q @@ -41,3 +52,7 @@ install -m 0644 %SOURCE1 %{buildroot}%{_libdir}/udev/rules.d %{_libdir}/udev/rules.d/99-sensor.rules %{_libdir}/sensor/*.so %license LICENSE.APLv2 + +%files haltests +%manifest packaging/%{name}.manifest +%{_bindir}/*haltest \ No newline at end of file diff --git a/src/accel/accel_device.cpp b/src/accel/accel_device.cpp old mode 100644 new mode 100755 index fd432fe..4b9f857 --- a/src/accel/accel_device.cpp +++ b/src/accel/accel_device.cpp @@ -51,6 +51,8 @@ #define MIN_RANGE(RES) (-((1 << (RES))/2)) #define MAX_RANGE(RES) (((1 << (RES))/2)-1) +#define MAX_ID 0x3 + static sensor_info_t sensor_info = { id: 0x1, name: SENSOR_NAME, @@ -142,6 +144,7 @@ int accel_device::get_poll_fd(void) int accel_device::get_sensors(const sensor_info_t **sensors) { + retvm_if(sensors == NULL || sensors == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL interface", SENSOR_NAME); *sensors = &sensor_info; return 1; @@ -149,6 +152,8 @@ int accel_device::get_sensors(const sensor_info_t **sensors) bool accel_device::enable(uint32_t id) { + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + util::set_enable_node(m_enable_node, m_sensorhub_controlled, true, SENSORHUB_ACCELEROMETER_ENABLE_BIT); set_interval(id, m_polling_interval); @@ -159,6 +164,8 @@ bool accel_device::enable(uint32_t id) bool accel_device::disable(uint32_t id) { + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + util::set_enable_node(m_enable_node, m_sensorhub_controlled, false, SENSORHUB_ACCELEROMETER_ENABLE_BIT); _I("Disable accelerometer sensor"); @@ -168,6 +175,7 @@ bool accel_device::disable(uint32_t id) bool accel_device::set_interval(uint32_t id, unsigned long val) { unsigned long long polling_interval_ns; + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); polling_interval_ns = ((unsigned long long)(val) * 1000llu * 1000llu); @@ -193,7 +201,7 @@ bool accel_device::update_value_input_event(void) x = y = z = false; struct input_event accel_input; - _D("accel event detection!"); + _D("accel sensor event detection"); while ((syn == false) && (read_input_cnt < INPUT_MAX_BEFORE_SYN)) { int len = read(m_node_handle, &accel_input, sizeof(accel_input)); @@ -305,6 +313,8 @@ bool accel_device::update_value_iio(void) int accel_device::read_fd(uint32_t **ids) { + retvm_if(ids == NULL || ids == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL interface", SENSOR_NAME); + if (!update_value()) { _D("Failed to update value"); return false; @@ -321,6 +331,10 @@ int accel_device::read_fd(uint32_t **ids) int accel_device::get_data(uint32_t id, sensor_data_t **data, int *length) { sensor_data_t *sensor_data; + retvm_if(data == NULL || data == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL data interface", SENSOR_NAME); + retvm_if(length == NULL || length == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL length interface", SENSOR_NAME); + retvm_if(id == 0 || id > MAX_ID, SENSOR_ERROR_INVALID_PARAMETER, "%s:Invalid ID Received", SENSOR_NAME); + sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t)); retvm_if(!sensor_data, -ENOMEM, "Memory allocation failed"); diff --git a/src/proxi/proxi_device.cpp b/src/proxi/proxi_device.cpp old mode 100644 new mode 100755 index 8f97781..127b5a9 --- a/src/proxi/proxi_device.cpp +++ b/src/proxi/proxi_device.cpp @@ -47,6 +47,7 @@ #define RAW_DATA_TO_DISTANCE(x) ((x) * 5) +#define MAX_ID 0x3 static sensor_info_t sensor_info = { id: 0x1, name: SENSOR_NAME, @@ -125,6 +126,7 @@ int proxi_device::get_poll_fd(void) int proxi_device::get_sensors(const sensor_info_t **sensors) { + retvm_if(sensors == NULL || sensors == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL interface", SENSOR_NAME); *sensors = &sensor_info; return 1; @@ -132,6 +134,8 @@ int proxi_device::get_sensors(const sensor_info_t **sensors) bool proxi_device::enable(uint32_t id) { + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + util::set_enable_node(m_enable_node, m_sensorhub_controlled, true, SENSORHUB_PROXIMITY_ENABLE_BIT); m_fired_time = 0; @@ -141,6 +145,8 @@ bool proxi_device::enable(uint32_t id) bool proxi_device::disable(uint32_t id) { + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + util::set_enable_node(m_enable_node, m_sensorhub_controlled, false, SENSORHUB_PROXIMITY_ENABLE_BIT); _I("Disable proxi sensor"); @@ -176,6 +182,8 @@ bool proxi_device::update_value_input_event(void) int proxi_device::read_fd(uint32_t **ids) { + retvm_if(ids == NULL || ids == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL interface", SENSOR_NAME); + if (!update_value()) { _D("Failed to update value"); return false; @@ -192,6 +200,10 @@ int proxi_device::read_fd(uint32_t **ids) int proxi_device::get_data(uint32_t id, sensor_data_t **data, int *length) { sensor_data_t *sensor_data; + retvm_if(data == NULL || data == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL data interface", SENSOR_NAME); + retvm_if(length == NULL || length == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL length interface", SENSOR_NAME); + retvm_if(id == 0 || id > MAX_ID, SENSOR_ERROR_INVALID_PARAMETER, "%s:Invalid ID Received", SENSOR_NAME); + sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t)); retvm_if(!sensor_data, -ENOMEM, "Memory allocation failed"); diff --git a/src/sensor_common.h b/src/sensor_common.h old mode 100644 new mode 100755 index b549c96..e34ec3f --- a/src/sensor_common.h +++ b/src/sensor_common.h @@ -22,6 +22,8 @@ #define RAW_DATA_EVENT 0x0001 #define UNKNOWN_NAME "UNKNOWN" +#include + enum sensorhub_enable_bit { SENSORHUB_ACCELEROMETER_ENABLE_BIT = 0, @@ -53,4 +55,25 @@ enum sensorhub_enable_bit { SENSORHUB_ENABLE_BIT_MAX, }; -#endif /* _SENSOR_COMMON_H_ */ + +/** + * @brief Enumeration for errors. + * @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif + */ +typedef enum { + SENSOR_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */ + SENSOR_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */ + SENSOR_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + SENSOR_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ + SENSOR_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + SENSOR_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + SENSOR_ERROR_NO_DATA = TIZEN_ERROR_NO_DATA, /**< No data available + @if MOBILE (Since 3.0) @elseif WEARABLE (Since 2.3.2) @endif */ + SENSOR_ERROR_NOT_NEED_CALIBRATION = TIZEN_ERROR_SENSOR | 0x03, /**< Sensor doesn't need calibration */ + SENSOR_ERROR_OPERATION_FAILED = TIZEN_ERROR_SENSOR | 0x06, /**< Operation failed */ + SENSOR_ERROR_NOT_AVAILABLE = TIZEN_ERROR_SENSOR | 0x07, /**< The sensor is supported, but currently not available + @if MOBILE (Since 3.0) @elseif WEARABLE (Since 2.3.2) @endif */ +} sensor_error_e; + + +#endif /* __SENSOR_COMMON_H__ */ diff --git a/src/sensorhub/sensorhub.cpp b/src/sensorhub/sensorhub.cpp old mode 100644 new mode 100755 index fe63177..fc944a3 --- a/src/sensorhub/sensorhub.cpp +++ b/src/sensorhub/sensorhub.cpp @@ -23,6 +23,8 @@ #include "sensorhub_manager.h" #include "system_state.h" +#define MAX_ID 0x3 + sensorhub_device::sensorhub_device() { controller = &sensorhub_controller::get_instance(); @@ -63,7 +65,7 @@ int sensorhub_device::get_sensors(const sensor_info_t **sensors) bool sensorhub_device::enable(uint32_t id) { system_state_handler::get_instance().initialize(); - + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); controller->enable(); sensorhub_sensor *sensor = manager->get_sensor(id); @@ -78,7 +80,7 @@ bool sensorhub_device::enable(uint32_t id) bool sensorhub_device::disable(uint32_t id) { system_state_handler::get_instance().finalize(); - + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); controller->disable(); sensorhub_sensor *sensor = manager->get_sensor(id); @@ -92,8 +94,10 @@ bool sensorhub_device::disable(uint32_t id) bool sensorhub_device::set_interval(uint32_t id, unsigned long val) { - sensorhub_sensor *sensor = manager->get_sensor(id); - + sensorhub_sensor *sensor = NULL; + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + retvm_if(val < 0, false, "%s:Invalid value Received", SENSOR_NAME); + sensor = manager->get_sensor(id); if (!sensor) { ERR("Failed to set interval to sensor(0x%x)", id); return false; @@ -104,7 +108,9 @@ bool sensorhub_device::set_interval(uint32_t id, unsigned long val) bool sensorhub_device::set_batch_latency(uint32_t id, unsigned long val) { - sensorhub_sensor *sensor = manager->get_sensor(id); + sensorhub_sensor *sensor = NULL; + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + sensor = manager->get_sensor(id); if (!sensor) { ERR("Failed to set batch latency to sensor(0x%x)", id); @@ -118,8 +124,12 @@ bool sensorhub_device::set_attribute_int(uint32_t id, int32_t attribute, int32_t { int ret; - sensorhub_sensor *sensor = manager->get_sensor(id); + sensorhub_sensor *sensor = NULL; + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + retvm_if(value < 0, false, "%s:Invalid value Received", SENSOR_NAME); + retvm_if(attribute < 0, false, "%s:Invalid attribute Received", SENSOR_NAME); + sensor = manager->get_sensor(id); if (!sensor) { ERR("Failed to set attribute to sensor(0x%x)", id); return false; @@ -144,7 +154,11 @@ bool sensorhub_device::set_attribute_str(uint32_t id, int32_t attribute, char *v { int ret; - sensorhub_sensor *sensor = manager->get_sensor(id); + sensorhub_sensor *sensor = NULL; + retvm_if(id == 0 || id > MAX_ID, false, "%s:Invalid ID Received", SENSOR_NAME); + retvm_if(value == NULL || value == nullptr, false, "%s:Invalid string Received", SENSOR_NAME); + retvm_if(value_len <= 0, false, "%s:Invalid value_len Received", SENSOR_NAME); + sensor = manager->get_sensor(id); if (!sensor) { ERR("Failed to set attribute to sensor(0x%x)", id); @@ -169,7 +183,7 @@ bool sensorhub_device::set_attribute_str(uint32_t id, int32_t attribute, char *v int sensorhub_device::read_fd(uint32_t **ids) { sensorhub_data_t data; - + retvm_if(ids == NULL || ids == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL interface", SENSOR_NAME); // step 1 if (!controller->read_fd(data)) return 0; @@ -207,6 +221,9 @@ int sensorhub_device::read_fd(uint32_t **ids) int sensorhub_device::get_data(uint32_t id, sensor_data_t **data, int *length) { int remains = 1; + retvm_if(data == NULL || data == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL data interface", SENSOR_NAME); + retvm_if(length == NULL || length == nullptr, SENSOR_ERROR_INVALID_PARAMETER, "%s:NULL length interface", SENSOR_NAME); + retvm_if(id == 0 || id > MAX_ID, SENSOR_ERROR_INVALID_PARAMETER, "%s:Invalid ID Received", SENSOR_NAME); sensorhub_sensor *sensor = manager->get_sensor(id); if (!sensor) { diff --git a/src/sensorhub/system_state.h b/src/sensorhub/system_state.h old mode 100644 new mode 100755 diff --git a/testcase/CMakeLists.txt b/testcase/CMakeLists.txt new file mode 100755 index 0000000..2e3ba05 --- /dev/null +++ b/testcase/CMakeLists.txt @@ -0,0 +1,30 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(sensor-haltest C CXX) +SET(GTEST_TEST "sensor-haltest") +ADD_DEFINITIONS("-DUSE_DLOG") + +SET(REQUIRES_LIST ${REQUIRES_LIST} + glib-2.0 + gio-2.0 + gmock + dlog ) +INCLUDE(FindPkgConfig) +pkg_check_modules(gtest_pkgs REQUIRED ${REQUIRES_LIST}) + +FOREACH(flag ${gtest_pkgs_CFLAGS}) +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wall -fPIE -fPIC") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS}") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie") + +aux_source_directory(. sources) +FOREACH(src ${sources}) + GET_FILENAME_COMPONENT (src_name ${src} NAME_WE) + MESSAGE("${src_name}") + ADD_EXECUTABLE(${src_name} ${SRCS} ${src}) + TARGET_LINK_LIBRARIES(${src_name} ${gtest_LDFLAGS} ${gtest_pkgs_LDFLAGS} -ldl) + INSTALL(TARGETS ${src_name} DESTINATION bin) +ENDFOREACH() \ No newline at end of file diff --git a/testcase/accel_device_haltest.cpp b/testcase/accel_device_haltest.cpp new file mode 100755 index 0000000..fdfd036 --- /dev/null +++ b/testcase/accel_device_haltest.cpp @@ -0,0 +1,407 @@ +/* + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include + + +#include +#include "sensor_common.h" + +using namespace std; + +#define SENSOR_NAME "SENSOR_ACCELEROMETER" +#define SENSOR_TYPE_ACCEL "ACCEL" + +#define INPUT_NAME "accelerometer_sensor" + + +int ret; +bool sensor_supported; +sensor_device *sensor_handle = NULL; + +#define SENSOR_SUPPORT_CHECK \ + do {\ + if (!sensor_supported) {\ + cout << "ACCEL SENSOR NOT SUPPORTED" << endl;\ + EXPECT_EQ(ret, SENSOR_ERROR_NOT_SUPPORTED);\ + return;\ + }\ + } while (0) + + + +/* + * main class + */ +class AccelSensorHalTest : public testing::Test +{ + +public: + virtual void SetUp() + { + sensor_supported = false; + sensor_handle = new accel_device; + if (sensor_handle == NULL) { + cout << "accel sensor init failed " << endl; + return; + } + sensor_supported = true; + } + virtual void TearDown() + { + if(sensor_handle) { + delete sensor_handle; + sensor_handle = NULL; + } + sensor_supported = false; + } + /*int GetSupportedFormat(int index) + { + return 0; + }*/ +}; + + + +/** + * @testcase get_poll_fdP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, get fd of sensor device + * @apicovered get_poll_fd + * @passcase Returns valid node handle value + * @failcase Returns invalid node handle value + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, get_poll_fdP) +{ + SENSOR_SUPPORT_CHECK; + int node_handle = 0; + node_handle = sensor_handle->get_poll_fd(); + EXPECT_NE(node_handle, 0); +} + +/** + * @testcase get_sensorsP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Get sensor data + * @apicovered get_sensors + * @passcase get valid sensor info + * @failcase get invalid sensor info + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, get_sensorsP) +{ + SENSOR_SUPPORT_CHECK; + const sensor_info_t *sensor_info_tc = nullptr; + ret = sensor_handle->get_sensors(&sensor_info_tc); + EXPECT_NE(sensor_info_tc, nullptr); + EXPECT_EQ(ret, 1); +} + +/** + * @testcase get_sensorsN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Get sensor data + * @apicovered get_sensors + * @passcase when invalid parameter passed, returns invalid parameter error + * @failcase when invalid parameter passed, doesn't return invalid paramter error + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, get_sensorsN) +{ + SENSOR_SUPPORT_CHECK; + ret = sensor_handle->get_sensors(nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + +} + +/** + * @testcase enableP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Enable Sensor + * @apicovered enable + * @passcase when valid id passed, returns 1 + * @failcase when valid id passed, doesn't returns 1 + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, enableP) +{ + SENSOR_SUPPORT_CHECK; + bool res = false; + uint32_t id = 1; + res = sensor_handle->enable(id); + EXPECT_EQ(res, true); +} + +/** + * @testcase enableN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Enable Sensor + * @apicovered enable + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, enableN) +{ + SENSOR_SUPPORT_CHECK; + bool res = true; + uint32_t id = 0; + res = sensor_handle->enable(id); + EXPECT_EQ(res, false); + res = true; + id = 10; + res = sensor_handle->enable(id); + EXPECT_EQ(res, false); + +} + +/** + * @testcase disableP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Disable Sensor + * @apicovered disable + * @passcase when valid id passed, returns true + * @failcase when valid id passed, doesn't returns true + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, disableP) +{ + SENSOR_SUPPORT_CHECK; + bool res = false; + uint32_t id = 1; + res = sensor_handle->disable(id); + EXPECT_EQ(res, true); + +} + +/** + * @testcase disableN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Disable Sensor + * @apicovered disable + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, disableN) +{ + SENSOR_SUPPORT_CHECK; + bool res = true; + uint32_t id = 0; + res = sensor_handle->disable(id); + EXPECT_EQ(res, false); + res = true; + id = 10; + res = sensor_handle->disable(id); + EXPECT_EQ(res, false); +} + +/** + * @testcase read_fdP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Reads sensosr device id + * @apicovered read_fd + * @passcase get valid id and returns other than zero + * @failcase get invalid id and returns other zero + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, read_fdP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t *id = nullptr; + bool res = false; + res = sensor_handle->enable(1); + EXPECT_EQ(res, true); + ret = sensor_handle->read_fd(&id); + EXPECT_NE(id, nullptr); + EXPECT_NE(ret, 0); +} + +/** + * @testcase read_fdN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Reads sensosr device id + * @apicovered read_fd + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, read_fdN) +{ + SENSOR_SUPPORT_CHECK; + ret = sensor_handle->read_fd(nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); +} + +/** + * @testcase get_dataP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Gets Sensor data and data size + * @apicovered get_data + * @passcase Gets valid data and length and returns 0 + * @failcase Doesn't get valid or length or doesn't return 0 + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, get_dataP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + sensor_data_t *data = NULL; + int length = 0; + ret = sensor_handle->get_data(id, &data, &length); + EXPECT_EQ(ret, 0); + EXPECT_NE(data, nullptr); + EXPECT_NE(length, 0); +} + +/** + * @testcase get_dataN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type.... auto + * @description Negative, Gets Sensor data and data size + * @apicovered get_data + * @passcase Returns invalid parameter error + * @failcase Doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, get_dataN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + sensor_data_t *data = nullptr; + int length = 0; + ret = sensor_handle->get_data(id, nullptr, &length); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + data = nullptr; + ret = sensor_handle->get_data(id, &data, nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + id = 0; + data = nullptr; + length = 0; + ret = sensor_handle->get_data(id, &data, &length); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); +} + + +/** + * @testcase set_intervalP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Set Interval for sensor response + * @apicovered set_interval + * @passcase when innterval is set, it returns true + * @failcase Returns false + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, set_intervalP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + unsigned long val = 10; + bool res = false; + res = sensor_handle->set_interval(id, val); + EXPECT_EQ(res, true); + +} + +/** + * @testcase set_intervalN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Set Interval for sensor response + * @apicovered set_interval + * @passcase Returns Invalid paramter error + * @failcase Doesn't returns Invalid paramter error + * @precondition None + * @postcondition None + */ +TEST_F(AccelSensorHalTest, set_intervalN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 0; + unsigned long val = 1; + bool res = true; + res = sensor_handle->set_interval(id, val); + EXPECT_EQ(res, false); + id = 10; + res = true; + res = sensor_handle->set_interval(id, val); + EXPECT_EQ(res, false); + +} + + +int main(int argc, char **argv) +{ + testing::InitGoogleTest(&argc, argv); + + return RUN_ALL_TESTS(); +} + diff --git a/testcase/proxi_device_haltest.cpp b/testcase/proxi_device_haltest.cpp new file mode 100755 index 0000000..1c9f8d4 --- /dev/null +++ b/testcase/proxi_device_haltest.cpp @@ -0,0 +1,356 @@ +/* + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include + + +#include "proxi/proxi_device.h" +#include "sensor_common.h" + +using namespace std; + +#define SENSOR_NAME "SENSOR_PROXIMITY" +#define SENSOR_TYPE_PROXI "PROXI" + +#define INPUT_NAME "proximity_sensor" +#define PROXI_SENSORHUB_POLL_NODE_NAME "prox_poll_delay" + + +int ret; +bool sensor_supported; +sensor_device *sensor_handle = NULL; + +#define SENSOR_SUPPORT_CHECK \ + do {\ + if (!sensor_supported) {\ + cout << "PROXIMITY SENSOR NOT SUPPORTED" << endl;\ + EXPECT_EQ(ret, SENSOR_ERROR_NOT_SUPPORTED);\ + return;\ + }\ + } while (0) + + + +/* + * main class + */ +class ProxiSensorHalTest : public testing::Test +{ + +public: + virtual void SetUp() + { + sensor_supported = false; + sensor_handle = new proxi_device; + if (sensor_handle == NULL) { + cout << "proximity sensor init failed " << endl; + return; + } + sensor_supported = true; + } + virtual void TearDown() + { + if(sensor_handle) { + delete sensor_handle; + sensor_handle = NULL; + } + sensor_supported = false; + } + /*int GetSupportedFormat(int index) + { + return 0; + }*/ +}; + + + +/** + * @testcase get_poll_fdP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, get fd of sensor device + * @apicovered get_poll_fd + * @passcase Returns valid node handle value + * @failcase Returns invalid node handle value + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, get_poll_fdP) +{ + SENSOR_SUPPORT_CHECK; + int node_handle = 0; + node_handle = sensor_handle->get_poll_fd(); + EXPECT_NE(node_handle, 0); +} + +/** + * @testcase get_sensorsP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Get sensor data + * @apicovered get_sensors + * @passcase get valid sensor info + * @failcase get invalid sensor info + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, get_sensorsP) +{ + SENSOR_SUPPORT_CHECK; + const sensor_info_t *sensor_info_tc = nullptr; + ret = sensor_handle->get_sensors(&sensor_info_tc); + EXPECT_NE(sensor_info_tc, nullptr); + EXPECT_EQ(ret, 1); +} + +/** + * @testcase get_sensorsN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Get sensor data + * @apicovered get_sensors + * @passcase when invalid parameter passed, returns invalid parameter error + * @failcase when invalid parameter passed, doesn't return invalid paramter error + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, get_sensorsN) +{ + SENSOR_SUPPORT_CHECK; + ret = sensor_handle->get_sensors(nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + +} + +/** + * @testcase enableP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Enable Sensor + * @apicovered enable + * @passcase when valid id passed, returns 1 + * @failcase when valid id passed, doesn't returns 1 + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, enableP) +{ + SENSOR_SUPPORT_CHECK; + bool res = false; + uint32_t id = 1; + res = sensor_handle->enable(id); + EXPECT_EQ(res, true); +} + +/** + * @testcase enableN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Enable Sensor + * @apicovered enable + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, enableN) +{ + SENSOR_SUPPORT_CHECK; + bool res = true; + uint32_t id = 0; + res = sensor_handle->enable(id); + EXPECT_EQ(res, false); + res = true; + id = 10; + res = sensor_handle->enable(id); + EXPECT_EQ(res, false); + +} + +/** + * @testcase disableP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Disable Sensor + * @apicovered disable + * @passcase when valid id passed, returns true + * @failcase when valid id passed, doesn't returns true + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, disableP) +{ + SENSOR_SUPPORT_CHECK; + bool res = false; + uint32_t id = 1; + res = sensor_handle->disable(id); + EXPECT_EQ(res, true); + +} + +/** + * @testcase disableN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Disable Sensor + * @apicovered disable + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, disableN) +{ + SENSOR_SUPPORT_CHECK; + bool res = true; + uint32_t id = 0; + res = sensor_handle->disable(id); + EXPECT_EQ(res, false); + res = true; + id = 10; + res = sensor_handle->disable(id); + EXPECT_EQ(res, false); +} + + +/** + * @testcase get_dataP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Gets Sensor data and data size + * @apicovered get_data + * @passcase Gets valid data and length and returns 0 + * @failcase Doesn't get valid or length or doesn't return 0 + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, get_dataP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + sensor_data_t *data = NULL; + int length = 0; + ret = sensor_handle->get_data(id, &data, &length); + EXPECT_EQ(ret, 0); + EXPECT_NE(data, nullptr); + EXPECT_NE(length, 0); +} + +/** + * @testcase get_dataN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type.... auto + * @description Negative, Gets Sensor data and data size + * @apicovered get_data + * @passcase Returns invalid parameter error + * @failcase Doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, get_dataN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + sensor_data_t *data = nullptr; + int length = 0; + ret = sensor_handle->get_data(id, nullptr, &length); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + data = nullptr; + ret = sensor_handle->get_data(id, &data, nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + id = 0; + data = nullptr; + length = 0; + ret = sensor_handle->get_data(id, &data, &length); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); +} + + +/** + * @testcase read_fdP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Reads sensosr device id + * @apicovered read_fd + * @passcase get valid id and returns other than zero + * @failcase get invalid id and returns other zero + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, read_fdP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t *id = nullptr; + bool res = false; + res = sensor_handle->enable(1); + EXPECT_EQ(res, true); + ret = sensor_handle->read_fd(&id); + EXPECT_NE(id, nullptr); + EXPECT_NE(ret, 0); +} + +/** + * @testcase read_fdN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Reads sensosr device id + * @apicovered read_fd + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(ProxiSensorHalTest, read_fdN) +{ + SENSOR_SUPPORT_CHECK; + ret = sensor_handle->read_fd(nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); +} + +int main(int argc, char **argv) +{ + testing::InitGoogleTest(&argc, argv); + + return RUN_ALL_TESTS(); +} + diff --git a/testcase/sensorhub_device_haltest.cpp b/testcase/sensorhub_device_haltest.cpp new file mode 100755 index 0000000..d4b8d0b --- /dev/null +++ b/testcase/sensorhub_device_haltest.cpp @@ -0,0 +1,569 @@ +/* + * Copyright (c) 2018 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include + + +#include "sensorhub/sensorhub.h" +#include "sensor_common.h" + +using namespace std; + +#define INPUT_NAME "sensorhub_sensor" +#ifdef SENSORHUB + +int ret; +bool sensor_supported; +sensor_device *sensor_handle = NULL; + +#define SENSOR_SUPPORT_CHECK \ + do {\ + if (!sensor_supported) {\ + cout << "SENSORHUB SENSOR NOT SUPPORTED" << endl;\ + EXPECT_EQ(ret, SENSOR_ERROR_NOT_SUPPORTED);\ + return;\ + }\ + } while (0) + + + +/* + * main class + */ +class SensorHubHalTest : public testing::Test +{ + +public: + virtual void SetUp() + { + sensor_supported = false; + sensor_handle = new sensorhub_device; + if (sensor_handle == NULL) { + cout << "Sensorhub sensor init failed " << endl; + return; + } + sensor_supported = true; + } + virtual void TearDown() + { + if(sensor_handle) { + delete sensor_handle; + sensor_handle = NULL; + } + sensor_supported = false; + } + /*int GetSupportedFormat(int index) + { + return 0; + }*/ +}; + + + +/** + * @testcase get_poll_fdP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, get fd of sensor device + * @apicovered get_poll_fd + * @passcase Returns valid node handle value + * @failcase Returns invalid node handle value + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, get_poll_fdP) +{ + SENSOR_SUPPORT_CHECK; + int node_handle = 0; + node_handle = sensor_handle->get_poll_fd(); + EXPECT_NE(node_handle, 0); +} + +/** + * @testcase get_sensorsP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Get sensor data + * @apicovered get_sensors + * @passcase get valid sensor info + * @failcase get invalid sensor info + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, get_sensorsP) +{ + SENSOR_SUPPORT_CHECK; + const sensor_info_t *sensor_info_tc = nullptr; + ret = sensor_handle->get_sensors(&sensor_info_tc); + EXPECT_NE(sensor_info_tc, nullptr); + EXPECT_EQ(ret, 1); +} + +/** + * @testcase get_sensorsN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Get sensor data + * @apicovered get_sensors + * @passcase when invalid parameter passed, returns invalid parameter error + * @failcase when invalid parameter passed, doesn't return invalid paramter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, get_sensorsN) +{ + SENSOR_SUPPORT_CHECK; + ret = sensor_handle->get_sensors(nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + +} + +/** + * @testcase enableP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Enable Sensor + * @apicovered enable + * @passcase when valid id passed, returns 1 + * @failcase when valid id passed, doesn't returns 1 + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, enableP) +{ + SENSOR_SUPPORT_CHECK; + bool res = false; + uint32_t id = 1; + res = sensor_handle->enable(id); + EXPECT_EQ(res, true); +} + +/** + * @testcase enableN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Enable Sensor + * @apicovered enable + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, enableN) +{ + SENSOR_SUPPORT_CHECK; + bool res = true; + uint32_t id = 0; + res = sensor_handle->enable(id); + EXPECT_EQ(res, false); + res = true; + id = 10; + res = sensor_handle->enable(id); + EXPECT_EQ(res, false); + +} + +/** + * @testcase disableP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Disable Sensor + * @apicovered disable + * @passcase when valid id passed, returns true + * @failcase when valid id passed, doesn't returns true + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, disableP) +{ + SENSOR_SUPPORT_CHECK; + bool res = false; + uint32_t id = 1; + res = sensor_handle->disable(id); + EXPECT_EQ(res, true); + +} + +/** + * @testcase disableN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Disable Sensor + * @apicovered disable + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, disableN) +{ + SENSOR_SUPPORT_CHECK; + bool res = true; + uint32_t id = 0; + res = sensor_handle->disable(id); + EXPECT_EQ(res, false); + res = true; + id = 10; + res = sensor_handle->disable(id); + EXPECT_EQ(res, false); +} + +/** + * @testcase read_fdP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Reads sensosr device id + * @apicovered read_fd + * @passcase get valid id and returns other than zero + * @failcase get invalid id and returns other zero + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, read_fdP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t *id = nullptr; + bool res = false; + res = sensor_handle->enable(1); + EXPECT_EQ(res, true); + ret = sensor_handle->read_fd(&id); + EXPECT_NE(id, nullptr); + EXPECT_NE(ret, 0); +} + +/** + * @testcase read_fdN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Reads sensosr device id + * @apicovered read_fd + * @passcase when invalid id passed, returns invalid parameter error + * @failcase when invalid id passed, doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, read_fdN) +{ + SENSOR_SUPPORT_CHECK; + ret = sensor_handle->read_fd(nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); +} + +/** + * @testcase get_dataP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Gets Sensor data and data size + * @apicovered get_data + * @passcase Gets valid data and length and returns 0 + * @failcase Doesn't get valid or length or doesn't return 0 + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, get_dataP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + sensor_data_t *data = NULL; + int length = 0; + ret = sensor_handle->get_data(id, &data, &length); + EXPECT_EQ(ret, 0); + EXPECT_NE(data, nullptr); + EXPECT_NE(length, 0); +} + +/** + * @testcase get_dataN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type.... auto + * @description Negative, Gets Sensor data and data size + * @apicovered get_data + * @passcase Returns invalid parameter error + * @failcase Doesn't returns invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, get_dataN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + sensor_data_t *data = nullptr; + int length = 0; + ret = sensor_handle->get_data(id, nullptr, &length); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + data = nullptr; + ret = sensor_handle->get_data(id, &data, nullptr); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); + id = 0; + data = nullptr; + length = 0; + ret = sensor_handle->get_data(id, &data, &length); + EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER); +} + + +/** + * @testcase set_intervalP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Set Interval for sensor response + * @apicovered set_interval + * @passcase when innterval is set, it returns true + * @failcase Returns false + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_intervalP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + unsigned long val = 10; + bool res = false; + res = sensor_handle->set_interval(id, val); + EXPECT_EQ(res, true); + +} + +/** + * @testcase set_intervalN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Set Interval for sensor response + * @apicovered set_interval + * @passcase Returns Invalid paramter error + * @failcase Doesn't returns Invalid paramter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_intervalN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 0; + unsigned long val = 1; + bool res = true; + res = sensor_handle->set_interval(id, val); + EXPECT_EQ(res, false); + id = 10; + res = true; + res = sensor_handle->set_interval(id, val); + EXPECT_EQ(res, false); + +} + +/** + * @testcase set_batch_latencyP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, sets batch latency to sensor + * @apicovered set_batch_latency + * @passcase upon latency setting it return SENSOR_ERROR_NONE + * @failcase upon latency setting it does not return SENSOR_ERROR_NONE + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_batch_latencyP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 0; + unsigned long val = 1; + bool res = false; + res = sensor_handle->set_batch_latency(id, val); + EXPECT_EQ(res, true); +} + +/** + * @testcase set_batch_latencyN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, sets batch latency to sensor + * @apicovered set_batch_latency + * @passcase upon latency setting it return Invalid parameter error + * @failcase upon latency setting it doesnot return Invalid parameter error + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_batch_latencyN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = -1; + unsigned long val = 1; + bool res = true; + res = sensor_handle->set_batch_latency(id, val); + EXPECT_EQ(res, false); + res = true; + val = -1; + res = sensor_handle->set_batch_latency(id, val); + EXPECT_EQ(res, false); + +} + +/** + * @testcase set_attribute_intP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Set Integer attribute + * @apicovered set_attribute_int + * @passcase upon attribute setting it reurns true + * @failcase upon attribute setting it reurns false + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_attribute_intP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + int32_t attribute = 1, val = 1; + bool res = false; + res = sensor_handle->set_attribute_int(id, attribute, val); + EXPECT_EQ(res, true); + +} + +/** + * @testcase set_attribute_intN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Set Integer attribute + * @apicovered set_attribute_int + * @passcase upon wrong attribute setting it reurns false + * @failcase upon wrong attribute setting it reurns true + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_attribute_intN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = -1; + int32_t attribute = 1, val = 1; + bool res = true; + res = sensor_handle->set_attribute_int(id, attribute, val); + EXPECT_EQ(res, false); + res = true; + attribute = -1; + id = 1; + res = sensor_handle->set_attribute_int(id, attribute, val); + EXPECT_EQ(res, false); + res = true; + attribute = 1; + id = 1; + val = -1; + res = sensor_handle->set_attribute_int(id, attribute, val); + EXPECT_EQ(res, false); + +} + +/** + * @testcase set_attribute_strP + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Positive, Set String attribute + * @apicovered set_attribute_str + * @passcase upon attribute setting it reurns true + * @failcase upon attribute setting it reurns false + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_attribute_strP) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + int32_t attribute = 1, len = 0; + char value[10] = "1"; + len = 2; + bool res = false; + res = sensor_handle->set_attribute_str(id, attribute, value, len); + EXPECT_EQ(res, true); + +} + +/** + * @testcase set_attribute_strN + * @since_tizen 4.0 + * @author SRID(srinivasa.m) + * @reviewer SRID(randeep.s) + * @type auto + * @description Negative, Set String attribute + * @apicovered set_attribute_str + * @passcase upon wrong attribute setting it reurns false + * @failcase upon wrong attribute setting it reurns true + * @precondition None + * @postcondition None + */ +TEST_F(SensorHubHalTest, set_attribute_strN) +{ + SENSOR_SUPPORT_CHECK; + uint32_t id = 1; + int32_t attribute = 1, len = 0; + char value[10] = "1"; + len = 3; + bool res = true; + res = sensor_handle->set_attribute_str(id, attribute, value, len); + EXPECT_EQ(res, false); + attribute = -1; + res = true; + res = sensor_handle->set_attribute_str(id, attribute, NULL, len); + EXPECT_EQ(res, false); +} +#endif + +int main(int argc, char **argv) +{ + testing::InitGoogleTest(&argc, argv); + + return RUN_ALL_TESTS(); +} +