src/sensorctl/testcase/sensor_listener.cpp

   1 /*
   2  * sensorctl
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <unistd.h>
  21 #include <string.h>
  22 #include <sensor_internal.h>
  23 #include <sensor_utils.h>
  24
  25 #include <client/sensor_manager.h>
  26 #include <client/sensor_listener.h>
  27
  28 #include "log.h"
  29 #include "mainloop.h"
  30 #include "test_bench.h"
  31
  32 static bool called = false;
  33 static int count = 0;
  34
  35 static void event_cb(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
  36 {
  37         _I("[%llu] %f %f %f\n", data->timestamp, data->values[0], data->values[1], data->values[2]);
  38
  39         if (count++ > 3)
  40                 mainloop::stop();
  41 }
  42
  43 TESTCASE(sensor_listener, get_default_sensor_p_1)
  44 {
  45         int err;
  46         sensor_t sensor;
  47
  48         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
  49         ASSERT_EQ(err, 0);
  50
  51         return true;
  52 }
  53
  54 TESTCASE(sensor_listener, get_sensors_p_1)
  55 {
  56         int err;
  57         int count;
  58         sensor_t *sensors;
  59
  60         err = sensord_get_sensors(ACCELEROMETER_SENSOR, &sensors, &count);
  61         ASSERT_EQ(err, 0);
  62         ASSERT_GT(count, 0);
  63
  64         free(sensors);
  65
  66         return true;
  67 }
  68
  69 TESTCASE(sensor_listener, connect_p_1)
  70 {
  71         int err;
  72         int handle;
  73         sensor_t sensor;
  74
  75         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
  76         ASSERT_EQ(err, 0);
  77
  78         handle = sensord_connect(sensor);
  79         ASSERT_GT(handle, 0);
  80
  81         err = sensord_disconnect(handle);
  82         ASSERT_EQ(err, 1);
  83
  84         return true;
  85 }
  86
  87 TESTCASE(sensor_listener, all_api_p_1)
  88 {
  89         int err;
  90         bool ret;
  91         int handle;
  92         sensor_t sensor;
  93         sensor_t *list;
  94         int count;
  95
  96         called = false;
  97
  98         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
  99         ASSERT_EQ(err, 0);
 100
 101         err = sensord_get_sensors(ALL_SENSOR, &list, &count);
 102         ASSERT_EQ(err, 0);
 103
 104         handle = sensord_connect(sensor);
 105         ASSERT_EQ(err, 0);
 106
 107         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 108         ASSERT_TRUE(ret);
 109
 110         ret = sensord_start(handle, 0);
 111         ASSERT_TRUE(ret);
 112
 113         ret = sensord_change_event_interval(handle, 0, 100);
 114         ASSERT_TRUE(ret);
 115
 116         ret = sensord_change_event_max_batch_latency(handle, 0, 100);
 117         ASSERT_TRUE(ret);
 118
 119         mainloop::run();
 120
 121         ret = sensord_stop(handle);
 122         ASSERT_TRUE(ret);
 123
 124         ret = sensord_unregister_event(handle, 1);
 125         ASSERT_TRUE(ret);
 126
 127         ret = sensord_disconnect(handle);
 128         ASSERT_TRUE(ret);
 129
 130         free(list);
 131
 132         return true;
 133 }
 134
 135 TESTCASE(sensor_listener, bad_unregister_stop_order_p_1)
 136 {
 137         int err;
 138         bool ret;
 139         int handle;
 140         sensor_t sensor;
 141
 142         called = false;
 143
 144         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 145         ASSERT_EQ(err, 0);
 146
 147         handle = sensord_connect(sensor);
 148         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 149         ret = sensord_start(handle, 0);
 150         ret = sensord_change_event_interval(handle, 0, 100);
 151
 152         mainloop::run();
 153
 154         /* [TEST] Unregister event before stop */
 155         ret = sensord_unregister_event(handle, 1);
 156         ASSERT_TRUE(ret);
 157
 158         ret = sensord_stop(handle);
 159         ASSERT_TRUE(ret);
 160
 161         ret = sensord_disconnect(handle);
 162         ASSERT_TRUE(ret);
 163
 164         return true;
 165 }
 166
 167 TESTCASE(sensor_listener, bad_disconnect_p_1)
 168 {
 169         int err;
 170         bool ret;
 171         int handle;
 172         sensor_t sensor;
 173
 174         called = false;
 175
 176         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 177         ASSERT_EQ(err, 0);
 178
 179         handle = sensord_connect(sensor);
 180         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 181         ret = sensord_start(handle, 0);
 182         ret = sensord_change_event_interval(handle, 0, 100);
 183
 184         mainloop::run();
 185
 186         /* [TEST] Unregistering event is not called */
 187
 188         ret = sensord_stop(handle);
 189         ASSERT_TRUE(ret);
 190
 191         ret = sensord_disconnect(handle);
 192         ASSERT_TRUE(ret);
 193
 194         return true;
 195 }
 196
 197 TESTCASE(sensor_listener, bad_disconnect_p_2)
 198 {
 199         int err;
 200         bool ret;
 201         int handle;
 202         sensor_t sensor;
 203
 204         called = false;
 205
 206         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 207         ASSERT_EQ(err, 0);
 208
 209         handle = sensord_connect(sensor);
 210         ret = sensord_register_event(handle, 1, 100, 100, event_cb, NULL);
 211         ret = sensord_start(handle, 0);
 212         ret = sensord_change_event_interval(handle, 0, 100);
 213
 214         mainloop::run();
 215
 216         ret = sensord_unregister_event(handle, 1);
 217         ASSERT_TRUE(ret);
 218
 219         /* [TEST] stopping sensor is not called */
 220
 221         ret = sensord_disconnect(handle);
 222         ASSERT_TRUE(ret);
 223
 224         return true;
 225 }
 226
 227 TESTCASE(sensor_listener, set_get_attribute_int_1)
 228 {
 229         int err = 0;
 230         bool ret = true;
 231         int handle = 0;
 232         sensor_t sensor = NULL;
 233         int attr = 1;
 234         int value = -1;
 235
 236         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 237         ASSERT_EQ(err, 0);
 238
 239         handle = sensord_connect(sensor);
 240         err = sensord_set_attribute_int(handle, attr, 1);
 241         ASSERT_EQ(err, 0);
 242
 243         err = sensord_get_attribute_int(handle, attr, &value);
 244         ASSERT_EQ(err, 0);
 245
 246         ASSERT_EQ(value, 1);
 247
 248         ret = sensord_disconnect(handle);
 249         ASSERT_TRUE(ret);
 250
 251         return true;
 252 }
 253
 254 TESTCASE(sensor_listener, set_get_attribute_int_2)
 255 {
 256         int err = 0;
 257         bool ret = true;
 258         int handle = 0;
 259         sensor_t sensor = NULL;
 260         int attr = 20;
 261         int value = -1;
 262
 263         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 264         ASSERT_EQ(err, 0);
 265
 266         handle = sensord_connect(sensor);
 267         err = sensord_set_attribute_int(handle, attr, 1);
 268         ASSERT_EQ(err, 0);
 269
 270         err = sensord_get_attribute_int(handle, attr, &value);
 271         ASSERT_EQ(err, 0);
 272
 273         ASSERT_EQ(value, 1);
 274
 275         ret = sensord_disconnect(handle);
 276         ASSERT_TRUE(ret);
 277
 278         return true;
 279 }
 280
 281 TESTCASE(sensor_listener, set_get_attribute_int_3)
 282 {
 283         int err = 0;
 284         bool ret = true;
 285         int handle = 0;
 286         sensor_t sensor = NULL;
 287         int attr = 20;
 288         int value = -1;
 289
 290         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 291         ASSERT_EQ(err, 0);
 292
 293         handle = sensord_connect(sensor);
 294
 295         err = sensord_set_attribute_int(handle, attr, 1);
 296         ASSERT_EQ(err, 0);
 297
 298         for (int i = 0 ; i < 10; i ++) {
 299                 err = sensord_get_attribute_int(handle, attr, &value);
 300                 ASSERT_EQ(err, 0);
 301         }
 302
 303         ASSERT_EQ(value, 1);
 304
 305         ret = sensord_disconnect(handle);
 306         ASSERT_TRUE(ret);
 307
 308         return true;
 309 }
 310
 311 TESTCASE(sensor_listener, get_attribute_int_1)
 312 {
 313         int err = 0;
 314         bool ret = true;
 315         int handle = 0;
 316         sensor_t sensor = NULL;
 317         int attr = 100;
 318         int value = -1;
 319
 320         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 321         ASSERT_EQ(err, 0);
 322
 323         handle = sensord_connect(sensor);
 324
 325         // attr 100 value is never set in these tests.
 326         err = sensord_get_attribute_int(handle, attr, &value);
 327         ASSERT_EQ(err, -5);
 328
 329         ret = sensord_disconnect(handle);
 330         ASSERT_TRUE(ret);
 331
 332         return true;
 333 }
 334
 335 #define TEST_STRING "TESTTESTTEST"
 336 #define TEST_STRING_LEN 13
 337
 338 TESTCASE(sensor_listener, set_attribute_string_1)
 339 {
 340         int err = 0;
 341         bool ret = true;
 342         int handle = 0;
 343         sensor_t sensor = NULL;
 344         int attr = 1;
 345
 346         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 347         ASSERT_EQ(err, 0);
 348
 349         handle = sensord_connect(sensor);
 350         err = sensord_set_attribute_str(handle, attr, TEST_STRING, TEST_STRING_LEN);
 351         ASSERT_EQ(err, 0);
 352
 353         ret = sensord_disconnect(handle);
 354         ASSERT_TRUE(ret);
 355
 356         return true;
 357 }
 358
 359 TESTCASE(sensor_listener, set_get_attribute_string_1)
 360 {
 361         int err = 0;
 362         bool ret = true;
 363         int handle = 0;
 364         char *value = NULL;
 365         int len = 0;
 366         sensor_t sensor = NULL;
 367         int attr = 1;
 368
 369         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 370         ASSERT_EQ(err, 0);
 371
 372         handle = sensord_connect(sensor);
 373         err = sensord_set_attribute_str(handle, attr, TEST_STRING, TEST_STRING_LEN);
 374         ASSERT_EQ(err, 0);
 375
 376         err = sensord_get_attribute_str(handle, attr, &value, &len);
 377         ASSERT_EQ(err, 0);
 378         ASSERT_EQ(len, TEST_STRING_LEN);
 379         ASSERT_EQ(strncmp(value, TEST_STRING, len), 0);
 380
 381         ret = sensord_disconnect(handle);
 382         ASSERT_TRUE(ret);
 383
 384         free(value);
 385         return true;
 386 }
 387
 388 #define BUF_SIZE 4000
 389 TESTCASE(sensor_listener, set_get_attribute_string_2)
 390 {
 391         int err = 0;
 392         bool ret = true;
 393         int handle = 0;
 394         char *value = NULL;
 395         int len = 0;
 396         sensor_t sensor = NULL;
 397         int attr = 1;
 398         char attr_value[BUF_SIZE] = {1, };
 399         attr_value[BUF_SIZE - 1] = 1;
 400
 401         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 402         ASSERT_EQ(err, 0);
 403
 404         handle = sensord_connect(sensor);
 405         err = sensord_set_attribute_str(handle, attr, attr_value, BUF_SIZE);
 406         ASSERT_EQ(err, 0);
 407
 408         err = sensord_get_attribute_str(handle, attr, &value, &len);
 409         ASSERT_EQ(err, 0);
 410         ASSERT_EQ(len, BUF_SIZE);
 411
 412         ret = sensord_disconnect(handle);
 413         ASSERT_TRUE(ret);
 414
 415         free(value);
 416         return true;
 417 }
 418
 419 TESTCASE(sensor_listener, set_get_attribute_string_3)
 420 {
 421         int err = 0;
 422         bool ret = true;
 423         int handle = 0;
 424         char *value = NULL;
 425         int len = 0;
 426         sensor_t sensor = NULL;
 427         int attr = 1;
 428
 429         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 430         ASSERT_EQ(err, 0);
 431
 432         handle = sensord_connect(sensor);
 433         err = sensord_set_attribute_str(handle, attr, TEST_STRING, TEST_STRING_LEN);
 434         ASSERT_EQ(err, 0);
 435
 436         for (int i = 0; i < 10; i++) {
 437                 err = sensord_get_attribute_str(handle, attr, &value, &len);
 438                 ASSERT_EQ(err, 0);
 439                 ASSERT_EQ(len, TEST_STRING_LEN);
 440                 ASSERT_EQ(strncmp(value, TEST_STRING, len), 0);
 441         }
 442
 443         ret = sensord_disconnect(handle);
 444         ASSERT_TRUE(ret);
 445
 446         free(value);
 447         return true;
 448 }
 449
 450 TESTCASE(sensor_listener, set_get_get_attribute_string_1)
 451 {
 452         int err;
 453         bool ret;
 454         int handle;
 455         char *value = NULL;
 456         int len = 0;
 457         sensor_t sensor;
 458         int attr = 1;
 459
 460         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 461         ASSERT_EQ(err, 0);
 462
 463         handle = sensord_connect(sensor);
 464         err = sensord_set_attribute_str(handle, attr, TEST_STRING, TEST_STRING_LEN);
 465         ASSERT_EQ(err, 0);
 466
 467         err = sensord_get_attribute_str(handle, attr, &value, &len);
 468         ASSERT_EQ(err, 0);
 469         ASSERT_EQ(len, TEST_STRING_LEN);
 470         ASSERT_EQ(strncmp(value, TEST_STRING, len), 0);
 471
 472         ret = sensord_disconnect(handle);
 473         ASSERT_TRUE(ret);
 474
 475         free(value);
 476
 477         value = NULL;
 478         len = 0;
 479
 480         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 481         ASSERT_EQ(err, 0);
 482
 483         handle = sensord_connect(sensor);
 484
 485         err = sensord_get_attribute_str(handle, attr, &value, &len);
 486         ASSERT_EQ(err, 0);
 487         ASSERT_EQ(len, TEST_STRING_LEN);
 488         ASSERT_EQ(strncmp(value, TEST_STRING, len), 0);
 489
 490         ret = sensord_disconnect(handle);
 491         ASSERT_TRUE(ret);
 492
 493         free(value);
 494         return true;
 495 }
 496
 497 TESTCASE(sensor_listener, get_attribute_string_2)
 498 {
 499         int err;
 500         bool ret;
 501         int handle;
 502         char *value;
 503         int len;
 504         sensor_t sensor;
 505         int attr = 100;
 506
 507         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 508         ASSERT_EQ(err, 0);
 509
 510         handle = sensord_connect(sensor);
 511
 512         // attr 100 value is never set in these tests.
 513         err = sensord_get_attribute_str(handle, attr, &value, &len);
 514         ASSERT_EQ(err, -EIO);
 515
 516         ret = sensord_disconnect(handle);
 517         ASSERT_TRUE(ret);
 518
 519         return true;
 520 }
 521
 522 #define SENSOR_SHIFT_TYPE 16
 523 TESTCASE(sensor_listener, get_data_list)
 524 {
 525         int err;
 526         bool ret;
 527         int handle;
 528         sensor_t sensor;
 529         sensor_type_t type;
 530
 531         called = false;
 532
 533         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 534         ASSERT_EQ(err, 0);
 535
 536         handle = sensord_connect(sensor);
 537
 538         sensord_get_type(sensor, &type);
 539         ASSERT_EQ(err, 0);
 540
 541         ret = sensord_start(handle, 0);
 542         ASSERT_TRUE(ret);
 543
 544         sensor_data_t* data_list = NULL;
 545         int count = 0;
 546         unsigned int data_id = type << SENSOR_SHIFT_TYPE | 0x1;
 547
 548         ret = sensord_get_data_list(handle, data_id, &data_list, &count);
 549         ASSERT_TRUE(ret);
 550         ASSERT_EQ(count, 1);
 551
 552         for (int i = 0 ; i < count; i++) {
 553                 _I("[%llu]", data_list[i].timestamp);
 554                 for (int j = 0; j < data_list[i].value_count; j++)
 555                         _I(" %f", data_list[i].values[j]);
 556                 _I("\n");
 557         }
 558         free(data_list);
 559
 560         ret = sensord_stop(handle);
 561         ASSERT_TRUE(ret);
 562
 563         ret = sensord_unregister_events(handle, 1);
 564         ASSERT_TRUE(ret);
 565
 566         ret = sensord_disconnect(handle);
 567         ASSERT_TRUE(ret);
 568
 569         return true;
 570 }
 571
 572 void sensor_attribute_int_changed_callback(sensor_t sensor, int attribute, int value, void *data)
 573 {
 574         _I("[ATTRIBUTE INT CHANGED] attribute : %d, value : %d\n", attribute, value);
 575 }
 576
 577 TESTCASE(skip_sensor_listener, register_attribute_int_changed)
 578 {
 579         int err;
 580         bool ret;
 581         int handle;
 582         sensor_t sensor;
 583
 584         called = false;
 585
 586         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 587         ASSERT_EQ(err, 0);
 588
 589         handle = sensord_connect(sensor);
 590         ASSERT_EQ(err, 0);
 591
 592         ret = sensord_register_attribute_int_changed_cb(handle, sensor_attribute_int_changed_callback, NULL);
 593         ASSERT_TRUE(ret);
 594
 595         ret = sensord_start(handle, 0);
 596         ASSERT_TRUE(ret);
 597
 598         mainloop::run();
 599
 600         ret = sensord_stop(handle);
 601         ASSERT_TRUE(ret);
 602
 603         ret = sensord_unregister_attribute_int_changed_cb(handle);
 604         ASSERT_TRUE(ret);
 605
 606         ret = sensord_disconnect(handle);
 607         ASSERT_TRUE(ret);
 608
 609         return true;
 610 }
 611
 612 static int attribute = 1; // 1 is SENSOR_ATTRIBUTE_AXIS_ORIENTATION of sensor_attribute_e in sensor.h
 613 static int attribute_value = 0;
 614
 615 static gboolean change_attribute_int(gpointer gdata)
 616 {
 617         int *handle = reinterpret_cast<int *>(gdata);
 618
 619         sensord_set_attribute_int(*handle, attribute, attribute_value);
 620
 621         _N("[ SET ATTRIBUTE INT ] attribute %d, value : %d\n", attribute, attribute_value);
 622
 623         g_timeout_add_seconds(1, change_attribute_int, handle);
 624
 625         attribute_value ? attribute_value = 0 : attribute_value = 1;
 626
 627         return FALSE;
 628 }
 629
 630 TESTCASE(skip_sensor_listener, attribute_int_changer)
 631 {
 632         int err;
 633         bool ret;
 634         int handle;
 635         sensor_t sensor;
 636
 637         called = false;
 638
 639         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 640         ASSERT_EQ(err, 0);
 641
 642         handle = sensord_connect(sensor);
 643         ASSERT_EQ(err, 0);
 644
 645         ret = sensord_start(handle, 0);
 646         ASSERT_TRUE(ret);
 647
 648         g_timeout_add_seconds(1, change_attribute_int, &handle);
 649         mainloop::run();
 650
 651         ret = sensord_stop(handle);
 652         ASSERT_TRUE(ret);
 653
 654         ret = sensord_disconnect(handle);
 655         ASSERT_TRUE(ret);
 656
 657         return true;
 658 }
 659
 660 void sensor_attribute_str_changed_callback(sensor_t sensor, int attribute, const char *value, int len, void *data)
 661 {
 662         _I("[ATTRIBUTE STR CHANGED] attribute : %d, value : %s, len : %d\n", attribute, value, len);
 663 }
 664
 665 TESTCASE(skip_sensor_listener, register_attribute_str_changed)
 666 {
 667         int err;
 668         bool ret;
 669         int handle;
 670         sensor_t sensor;
 671
 672         called = false;
 673
 674         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 675         ASSERT_EQ(err, 0);
 676
 677         handle = sensord_connect(sensor);
 678         ASSERT_EQ(err, 0);
 679
 680         ret = sensord_register_attribute_str_changed_cb(handle, sensor_attribute_str_changed_callback, NULL);
 681         ASSERT_TRUE(ret);
 682
 683         ret = sensord_start(handle, 0);
 684         ASSERT_TRUE(ret);
 685
 686         mainloop::run();
 687
 688         ret = sensord_stop(handle);
 689         ASSERT_TRUE(ret);
 690
 691         ret = sensord_unregister_attribute_str_changed_cb(handle);
 692         ASSERT_TRUE(ret);
 693
 694         ret = sensord_disconnect(handle);
 695         ASSERT_TRUE(ret);
 696
 697         return true;
 698 }
 699
 700 static const char *attribute_value_str1 = "test_str_1";
 701 static const char *attribute_value_str2 = "test_str_2";
 702 static const char *attribute_value_str = attribute_value_str1;
 703
 704 static gboolean change_attribute_str(gpointer gdata)
 705 {
 706         int *handle = reinterpret_cast<int *>(gdata);
 707         int len = strlen(attribute_value_str) + 1;
 708         sensord_set_attribute_str(*handle, attribute, attribute_value_str, len);
 709
 710         _N("[ SET ATTRIBUTE STR ] attribute %d, value : %s, len : %d\n", attribute, attribute_value_str, len);
 711
 712         g_timeout_add_seconds(1, change_attribute_str, handle);
 713
 714         if (attribute_value_str == attribute_value_str1) {
 715                 attribute_value_str = attribute_value_str2;
 716         } else {
 717                 attribute_value_str = attribute_value_str1;
 718         }
 719
 720         return FALSE;
 721 }
 722
 723 TESTCASE(skip_sensor_listener, attribute_str_changer)
 724 {
 725         int err;
 726         bool ret;
 727         int handle;
 728         sensor_t sensor;
 729
 730         called = false;
 731
 732         err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
 733         ASSERT_EQ(err, 0);
 734
 735         handle = sensord_connect(sensor);
 736         ASSERT_EQ(err, 0);
 737
 738         ret = sensord_start(handle, 0);
 739         ASSERT_TRUE(ret);
 740
 741         g_timeout_add_seconds(1, change_attribute_str, &handle);
 742         mainloop::run();
 743
 744         ret = sensord_stop(handle);
 745         ASSERT_TRUE(ret);
 746
 747         ret = sensord_disconnect(handle);
 748         ASSERT_TRUE(ret);
 749
 750         return true;
 751 }
 752
 753 TESTCASE(skip_sensor_listener, light_sensor_set_attribute_int_1)
 754 {
 755         int err = 0;
 756         bool ret = true;
 757         int handle = 0;
 758         sensor_t sensor = NULL;
 759         int attr = 2;
 760         int value = 0;
 761
 762         err = sensord_get_default_sensor(LIGHT_SENSOR, &sensor);
 763         ASSERT_EQ(err, 0);
 764
 765         handle = sensord_connect(sensor);
 766         err = sensord_set_attribute_int(handle, attr, 2);
 767         ASSERT_EQ(err, 0);
 768
 769         err = sensord_get_attribute_int(handle, attr, &value);
 770         ASSERT_EQ(err, 0);
 771         ASSERT_EQ(value, 2);
 772
 773         ret = sensord_disconnect(handle);
 774         ASSERT_TRUE(ret);
 775
 776         return true;
 777 }
 778
 779 TESTCASE(skip_sensor_listener, light_sensor_get_attribute_int_1)
 780 {
 781         int err = 0;
 782         bool ret = true;
 783         int handle = 0;
 784         sensor_t sensor = NULL;
 785         int attr = 2;
 786         int value = 0;
 787
 788         err = sensord_get_default_sensor(LIGHT_SENSOR, &sensor);
 789         ASSERT_EQ(err, 0);
 790
 791         handle = sensord_connect(sensor);
 792         err = sensord_get_attribute_int(handle, attr, &value);
 793         ASSERT_EQ(err, 0);
 794         ASSERT_EQ(value, 2);
 795
 796         ret = sensord_disconnect(handle);
 797         ASSERT_TRUE(ret);
 798
 799         return true;
 800 }