testcase/sensor_device_haltest.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <glib.h>
  19 #include <string.h>
  20 #include <gtest/gtest.h>
  21 #include <unistd.h>
  22 #include <iostream>
  23
  24
  25 #include <accel/accel_device.h>
  26 #include <proxi/proxi_device.h>
  27 #include <sensorhub/sensorhub.h>
  28 #include "sensor_common.h"
  29
  30 using namespace std;
  31
  32 //#define SENSOR_NAME "SENSOR_ACCELEROMETER"
  33 //#define SENSOR_TYPE_ACCEL "ACCEL"
  34
  35 //#define INPUT_NAME "accelerometer_sensor"
  36
  37
  38 #define SENSOR_SUPPORT_CHECK(name) \
  39         do {\
  40                 if (!sensor_supported) {\
  41                         cout << #name <<" SENSOR NOT SUPPORTED" << endl;\
  42                         EXPECT_EQ(ret, SENSOR_ERROR_NOT_SUPPORTED);\
  43                         return;\
  44                 }\
  45         } while (0)
  46
  47
  48
  49 /*
  50  * accel device test class
  51  */
  52 class AccelSensorHalTest : public testing::Test
  53 {
  54 public:
  55         int ret;
  56         bool sensor_supported;
  57         sensor_device *sensor_handle = NULL;
  58
  59 public:
  60         virtual void SetUp()
  61         {
  62                 sensor_supported = false;
  63                 sensor_handle = new accel_device;
  64                 if (sensor_handle == NULL) {
  65                         cout << "accel sensor init failed " << endl;
  66                         return;
  67                 }
  68                 sensor_supported = true;
  69         }
  70         virtual void TearDown()
  71         {
  72                 if(sensor_handle) {
  73                           delete sensor_handle;
  74                           sensor_handle = NULL;
  75                 }
  76                 sensor_supported = false;
  77         }
  78         /*int GetSupportedFormat(int index)
  79         {
  80                 return 0;
  81         }*/
  82 };
  83
  84 /*
  85  * proxi device test class
  86  */
  87 class ProxiSensorHalTest : public testing::Test
  88 {
  89 public:
  90         int ret;
  91         bool sensor_supported;
  92         sensor_device *sensor_handle = NULL;
  93
  94 public:
  95         virtual void SetUp()
  96         {
  97                 sensor_supported = false;
  98                 sensor_handle = new proxi_device;
  99                 if (sensor_handle == NULL) {
 100                         cout << "proximity sensor init failed " << endl;
 101                         return;
 102                 }
 103                 sensor_supported = true;
 104         }
 105         virtual void TearDown()
 106         {
 107                 if(sensor_handle) {
 108                           delete sensor_handle;
 109                           sensor_handle = NULL;
 110                 }
 111                 sensor_supported = false;
 112         }
 113         /*int GetSupportedFormat(int index)
 114         {
 115                 return 0;
 116         }*/
 117 };
 118
 119
 120
 121 #ifdef SENSORHUB
 122
 123 /*
 124  * sensorhub device test class
 125  */
 126 class SensorHubHalTest : public testing::Test
 127 {
 128 public:
 129         int ret;
 130         bool sensor_supported;
 131         sensor_device *sensor_handle = NULL;
 132
 133 public:
 134         virtual void SetUp()
 135         {
 136                 sensor_supported = false;
 137                 sensor_handle = new sensorhub_device;
 138                 if (sensor_handle == NULL) {
 139                         cout << "Sensorhub sensor init failed " << endl;
 140                         return;
 141                 }
 142                 sensor_supported = true;
 143         }
 144         virtual void TearDown()
 145         {
 146                 if(sensor_handle) {
 147                           delete sensor_handle;
 148                           sensor_handle = NULL;
 149                 }
 150                 sensor_supported = false;
 151         }
 152         /*int GetSupportedFormat(int index)
 153         {
 154                 return 0;
 155         }*/
 156 };
 157
 158 #endif
 159
 160 /**
 161  * @testcase            get_poll_fdP
 162  * @since_tizen         4.0
 163  * @author              SRID(srinivasa.m)
 164  * @reviewer            SRID(randeep.s)
 165  * @type                auto
 166  * @description         Positive, get fd of sensor device
 167  * @apicovered          get_poll_fd
 168  * @passcase            Returns valid node handle value
 169  * @failcase            Returns invalid node handle value
 170  * @precondition        None
 171  * @postcondition       None
 172  */
 173 TEST_F(AccelSensorHalTest, get_poll_fdP)
 174 {
 175         SENSOR_SUPPORT_CHECK(ACCEL);
 176         int node_handle = 0;
 177         node_handle = sensor_handle->get_poll_fd();
 178         EXPECT_NE(node_handle, 0);
 179 }
 180
 181 /**
 182  * @testcase            get_sensorsP
 183  * @since_tizen         4.0
 184  * @author              SRID(srinivasa.m)
 185  * @reviewer            SRID(randeep.s)
 186  * @type                auto
 187  * @description         Positive, Get sensor data
 188  * @apicovered          get_sensors
 189  * @passcase            get valid sensor info
 190  * @failcase            get invalid sensor info
 191  * @precondition        None
 192  * @postcondition       None
 193  */
 194 TEST_F(AccelSensorHalTest, get_sensorsP)
 195 {
 196         SENSOR_SUPPORT_CHECK(ACCEL);
 197         const sensor_info_t *sensor_info_tc = nullptr;
 198         ret = sensor_handle->get_sensors(&sensor_info_tc);
 199         EXPECT_NE(sensor_info_tc, nullptr);
 200         EXPECT_EQ(ret, 1);
 201 }
 202
 203 /**
 204  * @testcase            get_sensorsN
 205  * @since_tizen         4.0
 206  * @author              SRID(srinivasa.m)
 207  * @reviewer            SRID(randeep.s)
 208  * @type                auto
 209  * @description         Negative, Get sensor data
 210  * @apicovered          get_sensors
 211  * @passcase            when invalid parameter passed, returns invalid parameter error
 212  * @failcase            when invalid parameter passed, doesn't return invalid paramter error
 213  * @precondition        None
 214  * @postcondition       None
 215  */
 216 TEST_F(AccelSensorHalTest, get_sensorsN)
 217 {
 218         SENSOR_SUPPORT_CHECK(ACCEL);
 219         ret = sensor_handle->get_sensors(nullptr);
 220         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 221
 222 }
 223
 224 /**
 225  * @testcase            enableP
 226  * @since_tizen         4.0
 227  * @author              SRID(srinivasa.m)
 228  * @reviewer            SRID(randeep.s)
 229  * @type                auto
 230  * @description         Positive, Enable Sensor
 231  * @apicovered          enable
 232  * @passcase            when valid id passed, returns 1
 233  * @failcase            when valid id passed, doesn't returns 1
 234  * @precondition        None
 235  * @postcondition       None
 236  */
 237 TEST_F(AccelSensorHalTest, enableP)
 238 {
 239         SENSOR_SUPPORT_CHECK(ACCEL);
 240         bool res = false;
 241         uint32_t id = 1;
 242         res = sensor_handle->enable(id);
 243         EXPECT_EQ(res, true);
 244 }
 245
 246 /**
 247  * @testcase            enableN
 248  * @since_tizen         4.0
 249  * @author              SRID(srinivasa.m)
 250  * @reviewer            SRID(randeep.s)
 251  * @type                auto
 252  * @description         Negative, Enable Sensor
 253  * @apicovered          enable
 254  * @passcase            when invalid id passed, returns invalid parameter error
 255  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 256  * @precondition        None
 257  * @postcondition       None
 258  */
 259 TEST_F(AccelSensorHalTest, enableN)
 260 {
 261         SENSOR_SUPPORT_CHECK(ACCEL);
 262         bool res = true;
 263         uint32_t id = 0;
 264         res = sensor_handle->enable(id);
 265         EXPECT_EQ(res, false);
 266         res = true;
 267         id = 10;
 268         res = sensor_handle->enable(id);
 269         EXPECT_EQ(res, false);
 270
 271 }
 272
 273 /**
 274  * @testcase            disableP
 275  * @since_tizen         4.0
 276  * @author              SRID(srinivasa.m)
 277  * @reviewer            SRID(randeep.s)
 278  * @type                auto
 279  * @description         Positive, Disable Sensor
 280  * @apicovered          disable
 281  * @passcase            when valid id passed, returns true
 282  * @failcase            when valid id passed, doesn't returns true
 283  * @precondition        None
 284  * @postcondition       None
 285  */
 286 TEST_F(AccelSensorHalTest, disableP)
 287 {
 288         SENSOR_SUPPORT_CHECK(ACCEL);
 289         bool res = false;
 290         uint32_t id = 1;
 291         res = sensor_handle->disable(id);
 292         EXPECT_EQ(res, true);
 293
 294 }
 295
 296 /**
 297  * @testcase            disableN
 298  * @since_tizen         4.0
 299  * @author              SRID(srinivasa.m)
 300  * @reviewer            SRID(randeep.s)
 301  * @type                auto
 302  * @description         Negative, Disable Sensor
 303  * @apicovered          disable
 304  * @passcase            when invalid id passed, returns invalid parameter error
 305  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 306  * @precondition        None
 307  * @postcondition       None
 308  */
 309 TEST_F(AccelSensorHalTest, disableN)
 310 {
 311         SENSOR_SUPPORT_CHECK(ACCEL);
 312         bool res = true;
 313         uint32_t id = 0;
 314         res = sensor_handle->disable(id);
 315         EXPECT_EQ(res, false);
 316         res = true;
 317         id = 10;
 318         res = sensor_handle->disable(id);
 319         EXPECT_EQ(res, false);
 320 }
 321
 322 /**
 323  * @testcase            read_fdP
 324  * @since_tizen         4.0
 325  * @author              SRID(srinivasa.m)
 326  * @reviewer            SRID(randeep.s)
 327  * @type                auto
 328  * @description         Positive, Reads sensosr device id
 329  * @apicovered          read_fd
 330  * @passcase            get valid id and returns other than zero
 331  * @failcase            get invalid id and returns other zero
 332  * @precondition        None
 333  * @postcondition       None
 334  */
 335 TEST_F(AccelSensorHalTest, read_fdP)
 336 {
 337         SENSOR_SUPPORT_CHECK(ACCEL);
 338         uint32_t *id = nullptr;
 339         bool res = false;
 340         res = sensor_handle->enable(1);
 341         EXPECT_EQ(res, true);
 342         ret = sensor_handle->read_fd(&id);
 343         EXPECT_NE(id, nullptr);
 344         EXPECT_NE(ret, 0);
 345 }
 346
 347 /**
 348  * @testcase            read_fdN
 349  * @since_tizen         4.0
 350  * @author              SRID(srinivasa.m)
 351  * @reviewer            SRID(randeep.s)
 352  * @type                auto
 353  * @description         Negative, Reads sensosr device id
 354  * @apicovered          read_fd
 355  * @passcase            when invalid id passed, returns invalid parameter error
 356  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 357  * @precondition        None
 358  * @postcondition       None
 359  */
 360 TEST_F(AccelSensorHalTest, read_fdN)
 361 {
 362         SENSOR_SUPPORT_CHECK(ACCEL);
 363         ret = sensor_handle->read_fd(nullptr);
 364         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 365 }
 366
 367 /**
 368  * @testcase            get_dataP
 369  * @since_tizen         4.0
 370  * @author              SRID(srinivasa.m)
 371  * @reviewer            SRID(randeep.s)
 372  * @type                auto
 373  * @description         Positive, Gets Sensor data and data size
 374  * @apicovered          get_data
 375  * @passcase            Gets valid data and length and returns 0
 376  * @failcase            Doesn't get valid or length or doesn't return 0
 377  * @precondition        None
 378  * @postcondition       None
 379  */
 380 TEST_F(AccelSensorHalTest, get_dataP)
 381 {
 382         SENSOR_SUPPORT_CHECK(ACCEL);
 383         uint32_t id = 1;
 384         sensor_data_t *data = NULL;
 385         int length = 0;
 386         ret = sensor_handle->get_data(id, &data, &length);
 387         EXPECT_EQ(ret, 0);
 388         EXPECT_NE(data, nullptr);
 389         EXPECT_NE(length, 0);
 390 }
 391
 392 /**
 393  * @testcase            get_dataN
 394  * @since_tizen         4.0
 395  * @author              SRID(srinivasa.m)
 396  * @reviewer            SRID(randeep.s)
 397  * @type....            auto
 398  * @description         Negative, Gets Sensor data and data size
 399  * @apicovered          get_data
 400  * @passcase            Returns invalid parameter error
 401  * @failcase            Doesn't returns invalid parameter error
 402  * @precondition        None
 403  * @postcondition       None
 404  */
 405 TEST_F(AccelSensorHalTest, get_dataN)
 406 {
 407         SENSOR_SUPPORT_CHECK(ACCEL);
 408         uint32_t id = 1;
 409         sensor_data_t *data = nullptr;
 410         int length = 0;
 411         ret = sensor_handle->get_data(id, nullptr, &length);
 412         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 413         data = nullptr;
 414         ret = sensor_handle->get_data(id, &data, nullptr);
 415         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 416         id = 0;
 417         data = nullptr;
 418         length = 0;
 419         ret = sensor_handle->get_data(id, &data, &length);
 420         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 421 }
 422
 423
 424 /**
 425  * @testcase            set_intervalP
 426  * @since_tizen         4.0
 427  * @author              SRID(srinivasa.m)
 428  * @reviewer            SRID(randeep.s)
 429  * @type                auto
 430  * @description         Positive, Set Interval for sensor response
 431  * @apicovered          set_interval
 432  * @passcase            when innterval is set, it returns true
 433  * @failcase            Returns false
 434  * @precondition        None
 435  * @postcondition       None
 436  */
 437 TEST_F(AccelSensorHalTest, set_intervalP)
 438 {
 439         SENSOR_SUPPORT_CHECK(ACCEL);
 440         uint32_t id = 1;
 441         unsigned long val = 10;
 442         bool res = false;
 443         res = sensor_handle->set_interval(id, val);
 444         EXPECT_EQ(res, true);
 445
 446 }
 447
 448 /**
 449  * @testcase            set_intervalN
 450  * @since_tizen         4.0
 451  * @author              SRID(srinivasa.m)
 452  * @reviewer            SRID(randeep.s)
 453  * @type                auto
 454  * @description         Negative, Set Interval for sensor response
 455  * @apicovered          set_interval
 456  * @passcase            Returns Invalid paramter error
 457  * @failcase            Doesn't returns Invalid paramter error
 458  * @precondition        None
 459  * @postcondition       None
 460  */
 461 TEST_F(AccelSensorHalTest, set_intervalN)
 462 {
 463         SENSOR_SUPPORT_CHECK(ACCEL);
 464         uint32_t id = 0;
 465         unsigned long val = 1;
 466         bool res = true;
 467         res = sensor_handle->set_interval(id, val);
 468         EXPECT_EQ(res, false);
 469         id = 10;
 470         res = true;
 471         res = sensor_handle->set_interval(id, val);
 472         EXPECT_EQ(res, false);
 473
 474 }
 475
 476
 477 /**** PROXI Device TESTS **************/
 478
 479
 480 /**
 481  * @testcase            get_poll_fdP
 482  * @since_tizen         4.0
 483  * @author              SRID(srinivasa.m)
 484  * @reviewer            SRID(randeep.s)
 485  * @type                auto
 486  * @description         Positive, get fd of sensor device
 487  * @apicovered          get_poll_fd
 488  * @passcase            Returns valid node handle value
 489  * @failcase            Returns invalid node handle value
 490  * @precondition        None
 491  * @postcondition       None
 492  */
 493 TEST_F(ProxiSensorHalTest, get_poll_fdP)
 494 {
 495         SENSOR_SUPPORT_CHECK(PROXIMITY);
 496         int node_handle = 0;
 497         node_handle = sensor_handle->get_poll_fd();
 498         EXPECT_NE(node_handle, 0);
 499 }
 500
 501 /**
 502  * @testcase            get_sensorsP
 503  * @since_tizen         4.0
 504  * @author              SRID(srinivasa.m)
 505  * @reviewer            SRID(randeep.s)
 506  * @type                auto
 507  * @description         Positive, Get sensor data
 508  * @apicovered          get_sensors
 509  * @passcase            get valid sensor info
 510  * @failcase            get invalid sensor info
 511  * @precondition        None
 512  * @postcondition       None
 513  */
 514 TEST_F(ProxiSensorHalTest, get_sensorsP)
 515 {
 516         SENSOR_SUPPORT_CHECK(PROXIMITY);
 517         const sensor_info_t *sensor_info_tc = nullptr;
 518         ret = sensor_handle->get_sensors(&sensor_info_tc);
 519         EXPECT_NE(sensor_info_tc, nullptr);
 520         EXPECT_EQ(ret, 1);
 521 }
 522
 523 /**
 524  * @testcase            get_sensorsN
 525  * @since_tizen         4.0
 526  * @author              SRID(srinivasa.m)
 527  * @reviewer            SRID(randeep.s)
 528  * @type                auto
 529  * @description         Negative, Get sensor data
 530  * @apicovered          get_sensors
 531  * @passcase            when invalid parameter passed, returns invalid parameter error
 532  * @failcase            when invalid parameter passed, doesn't return invalid paramter error
 533  * @precondition        None
 534  * @postcondition       None
 535  */
 536 TEST_F(ProxiSensorHalTest, get_sensorsN)
 537 {
 538         SENSOR_SUPPORT_CHECK(PROXIMITY);
 539         ret = sensor_handle->get_sensors(nullptr);
 540         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 541
 542 }
 543
 544 /**
 545  * @testcase            enableP
 546  * @since_tizen         4.0
 547  * @author              SRID(srinivasa.m)
 548  * @reviewer            SRID(randeep.s)
 549  * @type                auto
 550  * @description         Positive, Enable Sensor
 551  * @apicovered          enable
 552  * @passcase            when valid id passed, returns 1
 553  * @failcase            when valid id passed, doesn't returns 1
 554  * @precondition        None
 555  * @postcondition       None
 556  */
 557 TEST_F(ProxiSensorHalTest, enableP)
 558 {
 559         SENSOR_SUPPORT_CHECK(PROXIMITY);
 560         bool res = false;
 561         uint32_t id = 1;
 562         res = sensor_handle->enable(id);
 563         EXPECT_EQ(res, true);
 564 }
 565
 566 /**
 567  * @testcase            enableN
 568  * @since_tizen         4.0
 569  * @author              SRID(srinivasa.m)
 570  * @reviewer            SRID(randeep.s)
 571  * @type                auto
 572  * @description         Negative, Enable Sensor
 573  * @apicovered          enable
 574  * @passcase            when invalid id passed, returns invalid parameter error
 575  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 576  * @precondition        None
 577  * @postcondition       None
 578  */
 579 TEST_F(ProxiSensorHalTest, enableN)
 580 {
 581         SENSOR_SUPPORT_CHECK(PROXIMITY);
 582         bool res = true;
 583         uint32_t id = 0;
 584         res = sensor_handle->enable(id);
 585         EXPECT_EQ(res, false);
 586         res = true;
 587         id = 10;
 588         res = sensor_handle->enable(id);
 589         EXPECT_EQ(res, false);
 590
 591 }
 592
 593 /**
 594  * @testcase            disableP
 595  * @since_tizen         4.0
 596  * @author              SRID(srinivasa.m)
 597  * @reviewer            SRID(randeep.s)
 598  * @type                auto
 599  * @description         Positive, Disable Sensor
 600  * @apicovered          disable
 601  * @passcase            when valid id passed, returns true
 602  * @failcase            when valid id passed, doesn't returns true
 603  * @precondition        None
 604  * @postcondition       None
 605  */
 606 TEST_F(ProxiSensorHalTest, disableP)
 607 {
 608         SENSOR_SUPPORT_CHECK(PROXIMITY);
 609         bool res = false;
 610         uint32_t id = 1;
 611         res = sensor_handle->disable(id);
 612         EXPECT_EQ(res, true);
 613
 614 }
 615
 616 /**
 617  * @testcase            disableN
 618  * @since_tizen         4.0
 619  * @author              SRID(srinivasa.m)
 620  * @reviewer            SRID(randeep.s)
 621  * @type                auto
 622  * @description         Negative, Disable Sensor
 623  * @apicovered          disable
 624  * @passcase            when invalid id passed, returns invalid parameter error
 625  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 626  * @precondition        None
 627  * @postcondition       None
 628  */
 629 TEST_F(ProxiSensorHalTest, disableN)
 630 {
 631         SENSOR_SUPPORT_CHECK(PROXIMITY);
 632         bool res = true;
 633         uint32_t id = 0;
 634         res = sensor_handle->disable(id);
 635         EXPECT_EQ(res, false);
 636         res = true;
 637         id = 10;
 638         res = sensor_handle->disable(id);
 639         EXPECT_EQ(res, false);
 640 }
 641
 642
 643 /**
 644  * @testcase            get_dataP
 645  * @since_tizen         4.0
 646  * @author              SRID(srinivasa.m)
 647  * @reviewer            SRID(randeep.s)
 648  * @type                auto
 649  * @description         Positive, Gets Sensor data and data size
 650  * @apicovered          get_data
 651  * @passcase            Gets valid data and length and returns 0
 652  * @failcase            Doesn't get valid or length or doesn't return 0
 653  * @precondition        None
 654  * @postcondition       None
 655  */
 656 TEST_F(ProxiSensorHalTest, get_dataP)
 657 {
 658         SENSOR_SUPPORT_CHECK(PROXIMITY);
 659         uint32_t id = 1;
 660         sensor_data_t *data = NULL;
 661         int length = 0;
 662         ret = sensor_handle->get_data(id, &data, &length);
 663         EXPECT_EQ(ret, 0);
 664         EXPECT_NE(data, nullptr);
 665         EXPECT_NE(length, 0);
 666 }
 667
 668 /**
 669  * @testcase            get_dataN
 670  * @since_tizen         4.0
 671  * @author              SRID(srinivasa.m)
 672  * @reviewer            SRID(randeep.s)
 673  * @type....            auto
 674  * @description         Negative, Gets Sensor data and data size
 675  * @apicovered          get_data
 676  * @passcase            Returns invalid parameter error
 677  * @failcase            Doesn't returns invalid parameter error
 678  * @precondition        None
 679  * @postcondition       None
 680  */
 681 TEST_F(ProxiSensorHalTest, get_dataN)
 682 {
 683         SENSOR_SUPPORT_CHECK(PROXIMITY);
 684         uint32_t id = 1;
 685         sensor_data_t *data = nullptr;
 686         int length = 0;
 687         ret = sensor_handle->get_data(id, nullptr, &length);
 688         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 689         data = nullptr;
 690         ret = sensor_handle->get_data(id, &data, nullptr);
 691         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 692         id = 0;
 693         data = nullptr;
 694         length = 0;
 695         ret = sensor_handle->get_data(id, &data, &length);
 696         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 697 }
 698
 699 #ifdef MANUAL_TEST
 700
 701 /**
 702  * @testcase            read_fdP
 703  * @since_tizen         4.0
 704  * @author              SRID(srinivasa.m)
 705  * @reviewer            SRID(randeep.s)
 706  * @type                auto
 707  * @description         Positive, Reads sensosr device id
 708  * @apicovered          read_fd
 709  * @passcase            get valid id and returns other than zero
 710  * @failcase            get invalid id and returns other zero
 711  * @precondition        None
 712  * @postcondition       None
 713  */
 714 TEST_F(ProxiSensorHalTest, read_fdP)
 715 {
 716         SENSOR_SUPPORT_CHECK(PROXIMITY);
 717         uint32_t *id = nullptr;
 718         bool res = false;
 719         res = sensor_handle->enable(1);
 720         EXPECT_EQ(res, true);
 721         ret = sensor_handle->read_fd(&id);
 722         EXPECT_NE(id, nullptr);
 723         EXPECT_NE(ret, 0);
 724 }
 725
 726 /**
 727  * @testcase            read_fdN
 728  * @since_tizen         4.0
 729  * @author              SRID(srinivasa.m)
 730  * @reviewer            SRID(randeep.s)
 731  * @type                auto
 732  * @description         Negative, Reads sensosr device id
 733  * @apicovered          read_fd
 734  * @passcase            when invalid id passed, returns invalid parameter error
 735  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 736  * @precondition        None
 737  * @postcondition       None
 738  */
 739 TEST_F(ProxiSensorHalTest, read_fdN)
 740 {
 741         SENSOR_SUPPORT_CHECK(PROXIMITY);
 742         ret = sensor_handle->read_fd(nullptr);
 743         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 744 }
 745 #endif  //MANUAL_TEST
 746
 747
 748 #ifdef SENSORHUB
 749                         /**** SENSORHUB Device TESTS **************/
 750
 751 /**
 752  * @testcase            get_poll_fdP
 753  * @since_tizen         4.0
 754  * @author              SRID(srinivasa.m)
 755  * @reviewer            SRID(randeep.s)
 756  * @type                auto
 757  * @description         Positive, get fd of sensor device
 758  * @apicovered          get_poll_fd
 759  * @passcase            Returns valid node handle value
 760  * @failcase            Returns invalid node handle value
 761  * @precondition        None
 762  * @postcondition       None
 763  */
 764 TEST_F(SensorHubHalTest, get_poll_fdP)
 765 {
 766         SENSOR_SUPPORT_CHECK(SENSORHUB);
 767         int node_handle = 0;
 768         node_handle = sensor_handle->get_poll_fd();
 769         EXPECT_NE(node_handle, 0);
 770 }
 771
 772 /**
 773  * @testcase            get_sensorsP
 774  * @since_tizen         4.0
 775  * @author              SRID(srinivasa.m)
 776  * @reviewer            SRID(randeep.s)
 777  * @type                auto
 778  * @description         Positive, Get sensor data
 779  * @apicovered          get_sensors
 780  * @passcase            get valid sensor info
 781  * @failcase            get invalid sensor info
 782  * @precondition        None
 783  * @postcondition       None
 784  */
 785 TEST_F(SensorHubHalTest, get_sensorsP)
 786 {
 787         SENSOR_SUPPORT_CHECK(SENSORHUB);
 788         const sensor_info_t *sensor_info_tc = nullptr;
 789         ret = sensor_handle->get_sensors(&sensor_info_tc);
 790         EXPECT_NE(sensor_info_tc, nullptr);
 791         EXPECT_EQ(ret, 1);
 792 }
 793
 794 /**
 795  * @testcase            get_sensorsN
 796  * @since_tizen         4.0
 797  * @author              SRID(srinivasa.m)
 798  * @reviewer            SRID(randeep.s)
 799  * @type                auto
 800  * @description         Negative, Get sensor data
 801  * @apicovered          get_sensors
 802  * @passcase            when invalid parameter passed, returns invalid parameter error
 803  * @failcase            when invalid parameter passed, doesn't return invalid paramter error
 804  * @precondition        None
 805  * @postcondition       None
 806  */
 807 TEST_F(SensorHubHalTest, get_sensorsN)
 808 {
 809         SENSOR_SUPPORT_CHECK(SENSORHUB);
 810         ret = sensor_handle->get_sensors(nullptr);
 811         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 812
 813 }
 814
 815 /**
 816  * @testcase            enableP
 817  * @since_tizen         4.0
 818  * @author              SRID(srinivasa.m)
 819  * @reviewer            SRID(randeep.s)
 820  * @type                auto
 821  * @description         Positive, Enable Sensor
 822  * @apicovered          enable
 823  * @passcase            when valid id passed, returns 1
 824  * @failcase            when valid id passed, doesn't returns 1
 825  * @precondition        None
 826  * @postcondition       None
 827  */
 828 TEST_F(SensorHubHalTest, enableP)
 829 {
 830         SENSOR_SUPPORT_CHECK(SENSORHUB);
 831         bool res = false;
 832         uint32_t id = 1;
 833         res = sensor_handle->enable(id);
 834         EXPECT_EQ(res, true);
 835 }
 836
 837 /**
 838  * @testcase            enableN
 839  * @since_tizen         4.0
 840  * @author              SRID(srinivasa.m)
 841  * @reviewer            SRID(randeep.s)
 842  * @type                auto
 843  * @description         Negative, Enable Sensor
 844  * @apicovered          enable
 845  * @passcase            when invalid id passed, returns invalid parameter error
 846  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 847  * @precondition        None
 848  * @postcondition       None
 849  */
 850 TEST_F(SensorHubHalTest, enableN)
 851 {
 852         SENSOR_SUPPORT_CHECK(SENSORHUB);
 853         bool res = true;
 854         uint32_t id = 0;
 855         res = sensor_handle->enable(id);
 856         EXPECT_EQ(res, false);
 857         res = true;
 858         id = 10;
 859         res = sensor_handle->enable(id);
 860         EXPECT_EQ(res, false);
 861
 862 }
 863
 864 /**
 865  * @testcase            disableP
 866  * @since_tizen         4.0
 867  * @author              SRID(srinivasa.m)
 868  * @reviewer            SRID(randeep.s)
 869  * @type                auto
 870  * @description         Positive, Disable Sensor
 871  * @apicovered          disable
 872  * @passcase            when valid id passed, returns true
 873  * @failcase            when valid id passed, doesn't returns true
 874  * @precondition        None
 875  * @postcondition       None
 876  */
 877 TEST_F(SensorHubHalTest, disableP)
 878 {
 879         SENSOR_SUPPORT_CHECK(SENSORHUB);
 880         bool res = false;
 881         uint32_t id = 1;
 882         res = sensor_handle->disable(id);
 883         EXPECT_EQ(res, true);
 884
 885 }
 886
 887 /**
 888  * @testcase            disableN
 889  * @since_tizen         4.0
 890  * @author              SRID(srinivasa.m)
 891  * @reviewer            SRID(randeep.s)
 892  * @type                auto
 893  * @description         Negative, Disable Sensor
 894  * @apicovered          disable
 895  * @passcase            when invalid id passed, returns invalid parameter error
 896  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 897  * @precondition        None
 898  * @postcondition       None
 899  */
 900 TEST_F(SensorHubHalTest, disableN)
 901 {
 902         SENSOR_SUPPORT_CHECK(SENSORHUB);
 903         bool res = true;
 904         uint32_t id = 0;
 905         res = sensor_handle->disable(id);
 906         EXPECT_EQ(res, false);
 907         res = true;
 908         id = 10;
 909         res = sensor_handle->disable(id);
 910         EXPECT_EQ(res, false);
 911 }
 912
 913 /**
 914  * @testcase            read_fdP
 915  * @since_tizen         4.0
 916  * @author              SRID(srinivasa.m)
 917  * @reviewer            SRID(randeep.s)
 918  * @type                auto
 919  * @description         Positive, Reads sensosr device id
 920  * @apicovered          read_fd
 921  * @passcase            get valid id and returns other than zero
 922  * @failcase            get invalid id and returns other zero
 923  * @precondition        None
 924  * @postcondition       None
 925  */
 926 TEST_F(SensorHubHalTest, read_fdP)
 927 {
 928         SENSOR_SUPPORT_CHECK(SENSORHUB);
 929         uint32_t *id = nullptr;
 930         bool res = false;
 931         res = sensor_handle->enable(1);
 932         EXPECT_EQ(res, true);
 933         ret = sensor_handle->read_fd(&id);
 934         EXPECT_NE(id, nullptr);
 935         EXPECT_NE(ret, 0);
 936 }
 937
 938 /**
 939  * @testcase            read_fdN
 940  * @since_tizen         4.0
 941  * @author              SRID(srinivasa.m)
 942  * @reviewer            SRID(randeep.s)
 943  * @type                auto
 944  * @description         Negative, Reads sensosr device id
 945  * @apicovered          read_fd
 946  * @passcase            when invalid id passed, returns invalid parameter error
 947  * @failcase            when invalid id passed, doesn't returns invalid parameter error
 948  * @precondition        None
 949  * @postcondition       None
 950  */
 951 TEST_F(SensorHubHalTest, read_fdN)
 952 {
 953         SENSOR_SUPPORT_CHECK(SENSORHUB);
 954         ret = sensor_handle->read_fd(nullptr);
 955         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
 956 }
 957
 958 /**
 959  * @testcase            get_dataP
 960  * @since_tizen         4.0
 961  * @author              SRID(srinivasa.m)
 962  * @reviewer            SRID(randeep.s)
 963  * @type                auto
 964  * @description         Positive, Gets Sensor data and data size
 965  * @apicovered          get_data
 966  * @passcase            Gets valid data and length and returns 0
 967  * @failcase            Doesn't get valid or length or doesn't return 0
 968  * @precondition        None
 969  * @postcondition       None
 970  */
 971 TEST_F(SensorHubHalTest, get_dataP)
 972 {
 973         SENSOR_SUPPORT_CHECK(SENSORHUB);
 974         uint32_t id = 1;
 975         sensor_data_t *data = NULL;
 976         int length = 0;
 977         ret = sensor_handle->get_data(id, &data, &length);
 978         EXPECT_EQ(ret, 0);
 979         EXPECT_NE(data, nullptr);
 980         EXPECT_NE(length, 0);
 981 }
 982
 983 /**
 984  * @testcase            get_dataN
 985  * @since_tizen         4.0
 986  * @author              SRID(srinivasa.m)
 987  * @reviewer            SRID(randeep.s)
 988  * @type....            auto
 989  * @description         Negative, Gets Sensor data and data size
 990  * @apicovered          get_data
 991  * @passcase            Returns invalid parameter error
 992  * @failcase            Doesn't returns invalid parameter error
 993  * @precondition        None
 994  * @postcondition       None
 995  */
 996 TEST_F(SensorHubHalTest, get_dataN)
 997 {
 998         SENSOR_SUPPORT_CHECK(SENSORHUB);
 999         uint32_t id = 1;
1000         sensor_data_t *data = nullptr;
1001         int length = 0;
1002         ret = sensor_handle->get_data(id, nullptr, &length);
1003         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
1004         data = nullptr;
1005         ret = sensor_handle->get_data(id, &data, nullptr);
1006         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
1007         id = 0;
1008         data = nullptr;
1009         length = 0;
1010         ret = sensor_handle->get_data(id, &data, &length);
1011         EXPECT_EQ(ret, SENSOR_ERROR_INVALID_PARAMETER);
1012 }
1013
1014
1015 /**
1016  * @testcase            set_intervalP
1017  * @since_tizen         4.0
1018  * @author              SRID(srinivasa.m)
1019  * @reviewer            SRID(randeep.s)
1020  * @type                auto
1021  * @description         Positive, Set Interval for sensor response
1022  * @apicovered          set_interval
1023  * @passcase            when innterval is set, it returns true
1024  * @failcase            Returns false
1025  * @precondition        None
1026  * @postcondition       None
1027  */
1028 TEST_F(SensorHubHalTest, set_intervalP)
1029 {
1030         SENSOR_SUPPORT_CHECK(SENSORHUB);
1031         uint32_t id = 1;
1032         unsigned long val = 10;
1033         bool res = false;
1034         res = sensor_handle->set_interval(id, val);
1035         EXPECT_EQ(res, true);
1036
1037 }
1038
1039 /**
1040  * @testcase            set_intervalN
1041  * @since_tizen         4.0
1042  * @author              SRID(srinivasa.m)
1043  * @reviewer            SRID(randeep.s)
1044  * @type                auto
1045  * @description         Negative, Set Interval for sensor response
1046  * @apicovered          set_interval
1047  * @passcase            Returns Invalid paramter error
1048  * @failcase            Doesn't returns Invalid paramter error
1049  * @precondition        None
1050  * @postcondition       None
1051  */
1052 TEST_F(SensorHubHalTest, set_intervalN)
1053 {
1054         SENSOR_SUPPORT_CHECK(SENSORHUB);
1055         uint32_t id = 0;
1056         unsigned long val = 1;
1057         bool res = true;
1058         res = sensor_handle->set_interval(id, val);
1059         EXPECT_EQ(res, false);
1060         id = 10;
1061         res = true;
1062         res = sensor_handle->set_interval(id, val);
1063         EXPECT_EQ(res, false);
1064
1065 }
1066
1067 /**
1068  * @testcase            set_batch_latencyP
1069  * @since_tizen         4.0
1070  * @author              SRID(srinivasa.m)
1071  * @reviewer            SRID(randeep.s)
1072  * @type                auto
1073  * @description         Positive, sets batch latency to sensor
1074  * @apicovered          set_batch_latency
1075  * @passcase            upon latency setting it return SENSOR_ERROR_NONE
1076  * @failcase            upon latency setting it does not return SENSOR_ERROR_NONE
1077  * @precondition        None
1078  * @postcondition       None
1079  */
1080 TEST_F(SensorHubHalTest, set_batch_latencyP)
1081 {
1082         SENSOR_SUPPORT_CHECK(SENSORHUB);
1083         uint32_t id = 0;
1084         unsigned long val = 1;
1085         bool res = false;
1086         res = sensor_handle->set_batch_latency(id, val);
1087         EXPECT_EQ(res, true);
1088 }
1089
1090 /**
1091  * @testcase            set_batch_latencyN
1092  * @since_tizen         4.0
1093  * @author              SRID(srinivasa.m)
1094  * @reviewer            SRID(randeep.s)
1095  * @type                auto
1096  * @description         Negative, sets batch latency to sensor
1097  * @apicovered          set_batch_latency
1098  * @passcase            upon latency setting it return Invalid parameter error
1099  * @failcase            upon latency setting it doesnot return Invalid parameter error
1100  * @precondition        None
1101  * @postcondition       None
1102  */
1103 TEST_F(SensorHubHalTest, set_batch_latencyN)
1104 {
1105         SENSOR_SUPPORT_CHECK(SENSORHUB);
1106         uint32_t id = -1;
1107         unsigned long val = 1;
1108         bool res = true;
1109         res = sensor_handle->set_batch_latency(id, val);
1110         EXPECT_EQ(res, false);
1111         res = true;
1112         val = -1;
1113         res = sensor_handle->set_batch_latency(id, val);
1114         EXPECT_EQ(res, false);
1115
1116 }
1117
1118 /**
1119  * @testcase            set_attribute_intP
1120  * @since_tizen         4.0
1121  * @author              SRID(srinivasa.m)
1122  * @reviewer            SRID(randeep.s)
1123  * @type                auto
1124  * @description         Positive, Set Integer attribute
1125  * @apicovered          set_attribute_int
1126  * @passcase            upon attribute setting it reurns true
1127  * @failcase            upon attribute setting it reurns false
1128  * @precondition        None
1129  * @postcondition       None
1130  */
1131 TEST_F(SensorHubHalTest, set_attribute_intP)
1132 {
1133         SENSOR_SUPPORT_CHECK(SENSORHUB);
1134         uint32_t id = 1;
1135         int32_t attribute = 1, val = 1;
1136         bool res = false;
1137         res = sensor_handle->set_attribute_int(id, attribute, val);
1138         EXPECT_EQ(res, true);
1139
1140 }
1141
1142 /**
1143  * @testcase            set_attribute_intN
1144  * @since_tizen         4.0
1145  * @author              SRID(srinivasa.m)
1146  * @reviewer            SRID(randeep.s)
1147  * @type                auto
1148  * @description         Negative, Set Integer attribute
1149  * @apicovered          set_attribute_int
1150  * @passcase            upon wrong attribute setting it reurns false
1151  * @failcase            upon wrong attribute setting it reurns true
1152  * @precondition        None
1153  * @postcondition       None
1154  */
1155 TEST_F(SensorHubHalTest, set_attribute_intN)
1156 {
1157         SENSOR_SUPPORT_CHECK(SENSORHUB);
1158         uint32_t id = -1;
1159         int32_t attribute = 1, val = 1;
1160         bool res = true;
1161         res = sensor_handle->set_attribute_int(id, attribute, val);
1162         EXPECT_EQ(res, false);
1163         res = true;
1164         attribute = -1;
1165         id =  1;
1166         res = sensor_handle->set_attribute_int(id, attribute, val);
1167         EXPECT_EQ(res, false);
1168         res = true;
1169         attribute = 1;
1170         id =  1;
1171         val = -1;
1172         res = sensor_handle->set_attribute_int(id, attribute, val);
1173         EXPECT_EQ(res, false);
1174
1175 }
1176
1177 /**
1178  * @testcase            set_attribute_strP
1179  * @since_tizen         4.0
1180  * @author              SRID(srinivasa.m)
1181  * @reviewer            SRID(randeep.s)
1182  * @type                auto
1183  * @description         Positive, Set String attribute
1184  * @apicovered          set_attribute_str
1185  * @passcase            upon attribute setting it reurns true
1186  * @failcase            upon attribute setting it reurns false
1187  * @precondition        None
1188  * @postcondition       None
1189  */
1190 TEST_F(SensorHubHalTest, set_attribute_strP)
1191 {
1192         SENSOR_SUPPORT_CHECK(SENSORHUB);
1193         uint32_t id = 1;
1194         int32_t attribute = 1, len = 0;
1195         char value[10] = "1";
1196         len = 2;
1197         bool res = false;
1198         res = sensor_handle->set_attribute_str(id, attribute, value, len);
1199         EXPECT_EQ(res, true);
1200
1201 }
1202
1203 /**
1204  * @testcase            set_attribute_strN
1205  * @since_tizen         4.0
1206  * @author              SRID(srinivasa.m)
1207  * @reviewer            SRID(randeep.s)
1208  * @type                auto
1209  * @description         Negative, Set String attribute
1210  * @apicovered          set_attribute_str
1211  * @passcase            upon wrong attribute setting it reurns false
1212  * @failcase            upon wrong attribute setting it reurns true
1213  * @precondition        None
1214  * @postcondition       None
1215  */
1216 TEST_F(SensorHubHalTest, set_attribute_strN)
1217 {
1218         SENSOR_SUPPORT_CHECK(SENSORHUB);
1219         uint32_t id = 1;
1220         int32_t attribute = 1, len = 0;
1221         char value[10] = "1";
1222         len = 3;
1223         bool res = true;
1224         res = sensor_handle->set_attribute_str(id, attribute, value, len);
1225         EXPECT_EQ(res, false);
1226         attribute = -1;
1227         res = true;
1228         res = sensor_handle->set_attribute_str(id, attribute, NULL, len);
1229         EXPECT_EQ(res, false);
1230 }
1231 #endif
1232
1233
1234 int main(int argc, char **argv)
1235 {
1236         testing::InitGoogleTest(&argc, argv);
1237
1238         return RUN_ALL_TESTS();
1239 }
1240