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