unittest/unittest.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   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 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20 #include <gmock/gmock.h>
  21 #include <gtest/gtest.h>
  22 #include <unistd.h>
  23
  24 #include "zbl.h"
  25
  26 using ::testing::InitGoogleTest;
  27 using ::testing::Test;
  28 using ::testing::TestCase;
  29
  30 TEST(ZigbeeManager, Enable_p)
  31 {
  32         int ret = ZIGBEE_ERROR_NONE;
  33         Zigbee zb_mgr;
  34
  35         ret = zb_mgr.zbl_enable();
  36         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
  37 }
  38
  39 TEST(ZigbeeManager, Disable_p)
  40 {
  41         int ret = ZIGBEE_ERROR_NONE;
  42         Zigbee zb_mgr;
  43
  44         ret = zb_mgr.zbl_disable();
  45         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
  46 }
  47
  48 TEST(ZigbeeManager, IsEnable_p)
  49 {
  50         int ret = ZIGBEE_ERROR_NONE;
  51         Zigbee zb_mgr;
  52         bool state;
  53
  54         ret = zb_mgr.zbl_is_enable(&state);
  55         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
  56 }
  57
  58 TEST(ZigbeeManager, Enable_p1)
  59 {
  60         int ret = ZIGBEE_ERROR_NONE;
  61         Zigbee zb_mgr;
  62
  63         ret = zb_mgr.zbl_enable();
  64         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
  65 }
  66
  67 TEST(ZigbeeManager, HwReset_p)
  68 {
  69         int ret = ZIGBEE_ERROR_NONE;
  70         Zigbee zb_mgr;
  71
  72         ret = zb_mgr.zbl_hw_reset();
  73         EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_IO_ERROR == ret) );
  74 }
  75
  76 TEST(ZigbeeManager, GetNetworkInfo_p)
  77 {
  78         int ret = ZIGBEE_ERROR_NONE;
  79         Zigbee zb_mgr;
  80
  81         ret = zb_mgr.zbl_get_network_info();
  82         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
  83 }
  84
  85 TEST(ZigbeeManager, GetControllerMacAddr_p)
  86 {
  87         int ret = ZIGBEE_ERROR_NONE;
  88         Zigbee zb_mgr;
  89         unsigned char mac[8];
  90
  91         ret = zb_mgr.zbl_get_controller_mac_address(mac);
  92         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
  93 }
  94
  95 TEST(ZigbeeManager, GetClusterList_p)
  96 {
  97         int ret = ZIGBEE_ERROR_NONE;
  98         Zigbee zb_mgr;
  99         unsigned char ep = 1;
 100         ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
 101                 0x02, 0xF2, 0x58, 0x5B };
 102         unsigned char in_count = 0;
 103         unsigned char out_count = 0;
 104         unsigned short in_cluster_list[MAX_ENDPOINT_CLUSTERS] = { 0 };
 105         unsigned short out_cluster_list[MAX_ENDPOINT_CLUSTERS] = { 0 };
 106
 107         ret = zb_mgr.zbl_get_cluster_list(dest_addr64, ep, &in_count,
 108                         in_cluster_list, &out_count, out_cluster_list);
 109         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 110 }
 111
 112 TEST(ZigbeeManager, GetEndPointList_p)
 113 {
 114         int ret = ZIGBEE_ERROR_NONE;
 115         Zigbee zb_mgr;
 116         ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
 117                 0x02, 0xF2, 0x58, 0x5B };
 118         unsigned char count = 0;
 119         unsigned char ep_list[10] = { 0 };
 120
 121         ret = zb_mgr.zbl_get_endpoint_list(dest_addr64, &count, ep_list);
 122         EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
 123 }
 124
 125 TEST(ZigbeeManager, ApiGetNodeType_p)
 126 {
 127         int ret = ZIGBEE_ERROR_NONE;
 128         Zigbee zb_mgr;
 129         ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
 130                 0x02, 0xF2, 0x58, 0x5B };
 131
 132         ret = zb_mgr.zbl_api_get_node_type(dest_addr64);
 133         EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
 134 }
 135
 136 TEST(ZigbeeManager, GetAllDeviceInfo_p)
 137 {
 138         int ret = ZIGBEE_ERROR_NONE;
 139         Zigbee zb_mgr;
 140
 141         ret = zb_mgr.zbl_get_all_device_info();
 142         EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
 143 }
 144
 145 TEST(ZigbeeManager, CoexStart_p)
 146 {
 147         int ret = ZIGBEE_ERROR_NONE;
 148         Zigbee zb_mgr;
 149         unsigned char channel = 11;
 150
 151         ret = zb_mgr.zbl_coex_start(channel);
 152         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 153 }
 154
 155 TEST(ZigbeeManager, CoexStop_p)
 156 {
 157         int ret = ZIGBEE_ERROR_NONE;
 158         Zigbee zb_mgr;
 159
 160         ret = zb_mgr.zbl_coex_stop();
 161         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 162 }
 163
 164 TEST(ZigbeeManager, FormNetwork_p)
 165 {
 166         int ret = ZIGBEE_ERROR_NONE;
 167         Zigbee zb_mgr;
 168
 169         ret = zb_mgr.zbl_form_network();
 170         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 171 }
 172
 173 TEST(ZigbeeManager, DisableNetwork_p)
 174 {
 175         int ret = ZIGBEE_ERROR_NONE;
 176         Zigbee zb_mgr;
 177
 178         ret = zb_mgr.zbl_disable_network();
 179         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 180 }
 181
 182 TEST(ZigbeeManager, LeaveDevice_p)
 183 {
 184         int ret = ZIGBEE_ERROR_NONE;
 185         Zigbee zb_mgr;
 186         ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
 187                 0x02, 0xF2, 0x58, 0x5B };
 188         bool remove_children = true;
 189         bool rejoin = false;
 190
 191         ret = zb_mgr.zbl_leave_device(dest_addr64, remove_children,
 192                         rejoin);
 193         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 194 }
 195
 196 TEST(ZigbeeManager, PermitJoin_p)
 197 {
 198         int ret = ZIGBEE_ERROR_NONE;
 199         Zigbee zb_mgr;
 200         unsigned char timeout = 90;
 201         bool broadcast = true;
 202
 203         ret = zb_mgr.zbl_permit_join(timeout, broadcast);
 204         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 205 }
 206
 207 TEST(ZigbeeManager, NwkAddrReq_p)
 208 {
 209         int ret = ZIGBEE_ERROR_NONE;
 210         Zigbee zb_mgr;
 211         ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
 212                 0x02, 0xF2, 0x58, 0x5B };
 213
 214         ret = zb_mgr.zbl_nwk_addr_req(dest_addr64, 0x00, 0x00);
 215         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 216 }
 217
 218 TEST(ZigbeeManager, IeeeAddrReq_p)
 219 {
 220         int ret = ZIGBEE_ERROR_NONE;
 221         Zigbee zb_mgr;
 222         nwk_addr dest_addr16 = 0x1D1A;
 223
 224         ret = zb_mgr.zbl_ieee_addr_req(dest_addr16);
 225         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 226 }
 227
 228 TEST(ZigbeeManager, ActiveEp_p)
 229 {
 230         int ret = ZIGBEE_ERROR_NONE;
 231         Zigbee zb_mgr;
 232         nwk_addr dest_addr16 = 0x1D1A;
 233
 234         ret = zb_mgr.zbl_active_ep(dest_addr16);
 235         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 236 }
 237
 238 TEST(ZigbeeManager, SimpleDescReq_p)
 239 {
 240         int ret = ZIGBEE_ERROR_NONE;
 241         Zigbee zb_mgr;
 242         nwk_addr dest_addr16 = 0x1D1A;
 243
 244         ret = zb_mgr.zbl_simple_desc_req(dest_addr16, 1);
 245         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 246 }
 247
 248 TEST(ZigbeeManager, MatchDescReq_p)
 249 {
 250         int ret = ZIGBEE_ERROR_NONE;
 251         Zigbee zb_mgr;
 252         nwk_addr dest_addr16 = 0x1D1A;
 253         unsigned char in_num = 0;
 254         unsigned char out_num = 0;
 255         unsigned short in_clusters[MAX_ENDPOINT_CLUSTERS] = { 0 };
 256         unsigned short out_clusters[MAX_ENDPOINT_CLUSTERS] = { 0 };
 257
 258         ret = zb_mgr.zbl_match_desc_req(dest_addr16, 0x00, in_num,
 259                         in_clusters, out_num, out_clusters);
 260         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 261 }
 262
 263 TEST(ZigbeeManager, NodeDescReq_p)
 264 {
 265         int ret = ZIGBEE_ERROR_NONE;
 266         Zigbee zb_mgr;
 267         nwk_addr dest_addr16 = 0x1D1A;
 268
 269         ret = zb_mgr.zbl_node_desc_req(dest_addr16);
 270         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 271 }
 272
 273 TEST(ZigbeeManager, PowerDescReq_p)
 274 {
 275         int ret = ZIGBEE_ERROR_NONE;
 276         Zigbee zb_mgr;
 277         nwk_addr dest_addr16 = 0x1D1A;
 278
 279         ret = zb_mgr.zbl_power_desc_req(dest_addr16);
 280         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 281 }
 282
 283 TEST(ZigbeeManager, ComplexDescReq_p)
 284 {
 285         int ret = ZIGBEE_ERROR_NONE;
 286         Zigbee zb_mgr;
 287         nwk_addr dest_addr16 = 0x1D1A;
 288
 289         ret = zb_mgr.zbl_complex_desc_req(dest_addr16);
 290         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 291 }
 292
 293 TEST(ZigbeeManager, UserDescReq_p)
 294 {
 295         int ret = ZIGBEE_ERROR_NONE;
 296         Zigbee zb_mgr;
 297         nwk_addr dest_addr16 = 0x1D1A;
 298
 299         ret = zb_mgr.zbl_user_desc_req(dest_addr16);
 300         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 301 }
 302
 303 TEST(ZigbeeManager, UserDescSet_p)
 304 {
 305         int ret = ZIGBEE_ERROR_NONE;
 306         Zigbee zb_mgr;
 307         nwk_addr dest_addr16 = 0x1D1A;
 308
 309         ret = zb_mgr.zbl_user_desc_set(dest_addr16, 4, (unsigned char *)"test");
 310         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 311 }
 312
 313 TEST(ZigbeeManager, DeviceAnnce_p)
 314 {
 315         int ret = ZIGBEE_ERROR_NONE;
 316         Zigbee zb_mgr;
 317         nwk_addr st_addr16 = 0x708B;
 318         ieee_addr st_addr64 = { 0x00, 0x0D, 0x6F, 0x00,
 319                 0x04, 0x2B, 0xBE, 0x14 };
 320
 321         ret = zb_mgr.zbl_device_annce(st_addr16, st_addr64,
 322                         ZB_ZDP_ALTERNATIVE_PAN_COORDINATOR | ZB_ZDP_DEVICE_TYPE
 323                         | ZB_ZDP_POWER_SOURCE | ZB_ZDP_RECEIVER_ON_WHEN_IDLE
 324                         | ZB_ZDP_ALLOCATE_ADDRESS);
 325         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 326 }
 327
 328 TEST(ZigbeeManager, BindReq_p)
 329 {
 330         int ret = ZIGBEE_ERROR_NONE;
 331         Zigbee zb_mgr;
 332         nwk_addr dest_addr16 = 0x1D1A;
 333         ieee_addr sj_addr64 = { 0x24, 0xFD, 0x5B, 0x00,
 334                 0x01, 0x01, 0x86, 0xB6 };
 335         ieee_addr co_addr64 = { 0xD0, 0x52, 0xA8, 0xA9,
 336                 0x8F, 0xB7, 0x00, 0x01 };
 337
 338         ret = zb_mgr.zbl_bind_req(dest_addr16, sj_addr64, 1, 0x0006,
 339                         co_addr64, 0x03, 0x0004, 1);
 340
 341         EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
 342 }
 343
 344 TEST(ZigbeeManager, UbindReq_p)
 345 {
 346         int ret = ZIGBEE_ERROR_NONE;
 347         Zigbee zb_mgr;
 348         nwk_addr dest_addr16 = 0x1D1A;
 349         ieee_addr sj_addr64 = { 0x24, 0xFD, 0x5B, 0x00,
 350                 0x01, 0x01, 0x86, 0xB6 };
 351         ieee_addr co_addr64 = { 0xD0, 0x52, 0xA8, 0xA9,
 352                 0x8F, 0xB7, 0x00, 0x01 };
 353
 354         ret = zb_mgr.zbl_unbind_req(dest_addr16, sj_addr64, 1, 0x0006,
 355                         co_addr64, 0x03, 0x0004, 1);
 356         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 357 }
 358
 359 TEST(ZigbeeManager, MgmtNwkDiscReq_p)
 360 {
 361         int ret = ZIGBEE_ERROR_NONE;
 362         Zigbee zb_mgr;
 363         nwk_addr dest_addr16 = 0x1D1A;
 364         unsigned int scan_channels = ZB_802_15_4_CHANNELS_MASK;
 365         unsigned char scan_duration = 5;
 366         unsigned char scan_count = 4;
 367         unsigned char start_idx = 0;
 368
 369         ret = zb_mgr.zbl_mgmt_nwk_disc_req(dest_addr16, scan_channels,
 370                         scan_duration, scan_count, start_idx);
 371         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 372 }
 373
 374 TEST(ZigbeeManager, MgmtNwkUpdateReq_p)
 375 {
 376         int ret = ZIGBEE_ERROR_NONE;
 377         Zigbee zb_mgr;
 378         nwk_addr dest_addr16 = 0x1D1A;
 379         unsigned int scan_channels = ZB_802_15_4_CHANNELS_MASK;
 380         unsigned char scan_duration = 5;
 381         unsigned char scan_count = 4;
 382         unsigned char start_idx = 0;
 383
 384         ret = zb_mgr.zbl_mgmt_nwk_update_req(dest_addr16, scan_channels,
 385                         scan_duration, scan_count, start_idx);
 386         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 387 }
 388
 389 TEST(ZigbeeManager, MgmtLqiReq_p)
 390 {
 391         int ret = ZIGBEE_ERROR_NONE;
 392         Zigbee zb_mgr;
 393         nwk_addr dest_addr16 = 0x1D1A;
 394         unsigned char start_idx = 0;
 395
 396         ret = zb_mgr.zbl_mgmt_lqi_req(dest_addr16, start_idx);
 397         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 398 }
 399
 400 TEST(ZigbeeManager, MgmtRtgReq_p)
 401 {
 402         int ret = ZIGBEE_ERROR_NONE;
 403         Zigbee zb_mgr;
 404         nwk_addr dest_addr16 = 0x1D1A;
 405         unsigned char start_idx = 0;
 406
 407         ret = zb_mgr.zbl_mgmt_rtg_req(dest_addr16, start_idx);
 408         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 409 }
 410
 411 TEST(ZigbeeManager, MgmtBindReq_p)
 412 {
 413         int ret = ZIGBEE_ERROR_NONE;
 414         Zigbee zb_mgr;
 415         nwk_addr dest_addr16 = 0x1D1A;
 416         unsigned char start_idx = 0;
 417
 418         ret = zb_mgr.zbl_mgmt_bind_req(dest_addr16, start_idx);
 419         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 420 }
 421
 422 TEST(ZigbeeManager, MgmtLeaveDevice_p)
 423 {
 424         int ret = ZIGBEE_ERROR_NONE;
 425         Zigbee zb_mgr;
 426         bool remove_children = true;
 427         bool rejoin = true;
 428         ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
 429                 0x02, 0xF2, 0x58, 0x5B };
 430
 431         ret = zb_mgr.zbl_mgmt_leave_device(dest_addr64, remove_children, rejoin);
 432         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 433 }
 434
 435 TEST(ZigbeeManager, MgmtPermitJoiningReq_p)
 436 {
 437         int ret = ZIGBEE_ERROR_NONE;
 438         Zigbee zb_mgr;
 439         unsigned char permit_duration = 1;
 440         unsigned char tc_significance = 1;
 441         nwk_addr dest_addr16 = 0x1D1A;
 442
 443         ret = zb_mgr.zbl_mgmt_permit_joining_req(dest_addr16, permit_duration,
 444                         tc_significance);
 445         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 446 }
 447
 448 TEST(ZigbeeManager, ApsSend_p)
 449 {
 450         int ret = ZIGBEE_ERROR_NONE;
 451         Zigbee zb_mgr;
 452         unsigned char aps_frame_ctl = ZB_APS_DELIVERY_UNICAST | ZB_APS_NO_ACK_REQUEST;
 453         unsigned char src_ep = 1;
 454         unsigned char dst_ep = 1;
 455         unsigned short cluster_id = 0xFC05;
 456         unsigned short profile_id = 0xFC01;
 457         unsigned char zcl_frame_ctl = ZB_ZCL_FC_GLOBALLY_USED | ZB_ZCL_CLIENT_TO_SERVER |
 458                 ZB_ZCL_FC_NOT_MANUFACTURER | ZB_ZCL_DISABLE_DEFAULT_RESPONSE;
 459         unsigned short mfg_code = 0x110A;
 460         unsigned char cmd_id = 0x01;
 461         unsigned short payload_len = 4;
 462         unsigned char payload[4] = { 0x00, 0x01, 0x02, 0x03 };
 463         nwk_addr dest_addr16 = 0x1D1A;
 464
 465         ret = zb_mgr.zbl_aps_send(dest_addr16, aps_frame_ctl, src_ep, dst_ep, cluster_id,
 466                         profile_id, zcl_frame_ctl, mfg_code, cmd_id, payload_len, payload);
 467         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 468 }
 469
 470 TEST(ZigbeeManager, ZclSend_p)
 471 {
 472         int ret = ZIGBEE_ERROR_NONE;
 473         Zigbee zb_mgr;
 474         unsigned char src_ep = 2;
 475         unsigned char dst_ep = 2;
 476         unsigned short cluster_id = 0x0000;
 477         unsigned char zcl_frame_ctl = ZB_ZCL_FC_GLOBALLY_USED | ZB_ZCL_CLIENT_TO_SERVER |
 478                 ZB_ZCL_FC_NOT_MANUFACTURER | ZB_ZCL_DISABLE_DEFAULT_RESPONSE;
 479         unsigned char cmd = 0x0;
 480         unsigned short payload_len = 4;
 481         unsigned char payload[4] = { 0x00, 0x01, 0x02, 0x03 };
 482         nwk_addr dest_addr16 = 0x1D1A;
 483
 484         ret = zb_mgr.zbl_zcl_send(dest_addr16, src_ep, dst_ep, cluster_id,
 485                         zcl_frame_ctl, cmd, payload_len, payload);
 486         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 487 }
 488
 489 TEST(ZigbeeManager, SendToLocal_p)
 490 {
 491         int ret = ZIGBEE_ERROR_NONE;
 492         Zigbee zb_mgr;
 493         unsigned short length = 4;
 494         unsigned char data[4] = { 0x00, 0x01, 0x02, 0x03 };
 495
 496         ret = zb_mgr.zbl_send_to_local(length, data);
 497         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 498 }
 499
 500 TEST(ZigbeeManager, DiscoverCmdsGen_p)
 501 {
 502         int ret = ZIGBEE_ERROR_NONE;
 503         Zigbee zb_mgr;
 504         nwk_addr dest_addr16 = 0x1D1A;
 505
 506         ret = zb_mgr.zbl_discover_cmds_gen(dest_addr16, 1, 1,
 507                         ZB_ZCL_DISABLE_DEFAULT_RESPONSE, 0x0004, 0x00, 4);
 508         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 509 }
 510
 511 TEST(ZigbeeManager, DiscoverAttrExt_p)
 512 {
 513         int ret = ZIGBEE_ERROR_NONE;
 514         Zigbee zb_mgr;
 515         nwk_addr dest_addr16 = 0x1D1A;
 516
 517         ret = zb_mgr.zbl_discover_attr_ext(dest_addr16, 1, 1,
 518                         ZB_ZCL_DISABLE_DEFAULT_RESPONSE, 0x0006, 0x0000, 5);
 519         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 520 }
 521
 522 TEST(ZigbeeManager, ResetAlarm_p)
 523 {
 524         int ret = ZIGBEE_ERROR_NONE;
 525         Zigbee zb_mgr;
 526         unsigned char alarm_code = 0x01;
 527         nwk_addr dest_addr16 = 0x1D1A;
 528
 529         ret = zb_mgr.zbl_reset_alarm(dest_addr16, 1, alarm_code,
 530                         0x0006);
 531         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 532 }
 533
 534 TEST(ZigbeeManager, GetAlarm_p)
 535 {
 536         int ret = ZIGBEE_ERROR_NONE;
 537         Zigbee zb_mgr;
 538         nwk_addr dest_addr16 = 0x1D1A;
 539
 540         ret = zb_mgr.zbl_get_alarm(dest_addr16, 1);
 541         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 542 }
 543
 544 TEST(ZigbeeManager, ResetAllAlarmLog_p)
 545 {
 546         int ret = ZIGBEE_ERROR_NONE;
 547         Zigbee zb_mgr;
 548         nwk_addr dest_addr16 = 0x1D1A;
 549
 550         ret = zb_mgr.zbl_reset_all_alarm_log(dest_addr16, 1);
 551         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 552 }
 553
 554 TEST(ZigbeeManager, CcontrolMoveToHue_p)
 555 {
 556         int ret = ZIGBEE_ERROR_NONE;
 557         Zigbee zb_mgr;
 558         unsigned char move_hue = 0x20;
 559         unsigned char direction = 0x00;
 560         unsigned short trans_time16 = 0x00C8;
 561         nwk_addr dest_addr16 = 0x1D1A;
 562
 563         ret = zb_mgr.zbl_ccontrol_move_to_hue(dest_addr16, 1, move_hue,
 564                         direction, trans_time16);
 565         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 566 }
 567
 568 TEST(ZigbeeManager, CcontrolMoveHue_p)
 569 {
 570         int ret = ZIGBEE_ERROR_NONE;
 571         Zigbee zb_mgr;
 572         unsigned char move_mode = 0x03;
 573         unsigned char color_rate = 2;
 574         nwk_addr dest_addr16 = 0x1D1A;
 575
 576         ret = zb_mgr.zbl_ccontrol_move_hue(dest_addr16, 1, move_mode,
 577                         color_rate);
 578         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 579 }
 580
 581 TEST(ZigbeeManager, CcontrolStepHue_p)
 582 {
 583         int ret = ZIGBEE_ERROR_NONE;
 584         Zigbee zb_mgr;
 585         unsigned char step_mode = 0x03;
 586         unsigned char step_size = 0x20;
 587         unsigned char trans_time8 = 0x0A;
 588         nwk_addr dest_addr16 = 0x1D1A;
 589
 590         ret = zb_mgr.zbl_ccontrol_step_hue(dest_addr16, 1, step_mode,
 591                         step_size, trans_time8);
 592         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 593 }
 594
 595 TEST(ZigbeeManager, CcontrolMoveToSaturation_p)
 596 {
 597         int ret = ZIGBEE_ERROR_NONE;
 598         Zigbee zb_mgr;
 599         unsigned char saturation = 0x0A;
 600         unsigned char trans_time16 = 0x00C8;
 601         nwk_addr dest_addr16 = 0x1D1A;
 602
 603         ret = zb_mgr.zbl_ccontrol_move_to_saturation(dest_addr16, 1, saturation,
 604                         trans_time16);
 605         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 606 }
 607
 608 TEST(ZigbeeManager, CcontrolMoveSaturation_p)
 609 {
 610         int ret = ZIGBEE_ERROR_NONE;
 611         Zigbee zb_mgr;
 612         unsigned char move_mode = 0x03;
 613         unsigned char color_rate = 2;
 614         nwk_addr dest_addr16 = 0x1D1A;
 615
 616         ret = zb_mgr.zbl_ccontrol_move_saturation(dest_addr16, 1, move_mode,
 617                         color_rate);
 618         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 619 }
 620
 621 TEST(ZigbeeManager, CcontrolStepSaturation_p)
 622 {
 623         int ret = ZIGBEE_ERROR_NONE;
 624         Zigbee zb_mgr;
 625         unsigned char step_mode = 0x03;
 626         unsigned char step_size = 0x20;
 627         unsigned char trans_time8 = 0x0A;
 628         nwk_addr dest_addr16 = 0x1D1A;
 629
 630         ret = zb_mgr.zbl_ccontrol_step_saturation(dest_addr16, 1, step_mode,
 631                         step_size, trans_time8);
 632         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 633 }
 634
 635 TEST(ZigbeeManager, CcontrolMoveToHueAndSaturation_p)
 636 {
 637         int ret = ZIGBEE_ERROR_NONE;
 638         Zigbee zb_mgr;
 639         unsigned char move_hue = 0x20;
 640         unsigned char saturation = 0x0A;
 641         unsigned short trans_time16 = 0x00C8;
 642         nwk_addr dest_addr16 = 0x1D1A;
 643
 644         ret = zb_mgr.zbl_ccontrol_move_to_hue_and_saturation(dest_addr16, 1, move_hue,
 645                         saturation, trans_time16);
 646         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 647 }
 648
 649 TEST(ZigbeeManager, CcontrolMoveToColor_p)
 650 {
 651         int ret = ZIGBEE_ERROR_NONE;
 652         Zigbee zb_mgr;
 653         unsigned short color_x = 0x280A;
 654         unsigned short color_y = 0x2710;
 655         unsigned short trans_time16 = 0x00C8;
 656         nwk_addr dest_addr16 = 0x1D1A;
 657
 658         ret = zb_mgr.zbl_ccontrol_move_to_color(dest_addr16, 1, color_x,
 659                         color_y, trans_time16);
 660         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 661 }
 662
 663 TEST(ZigbeeManager, CcontrolMoveColor_p)
 664 {
 665         int ret = ZIGBEE_ERROR_NONE;
 666         Zigbee zb_mgr;
 667         unsigned short rate_x = 0x0002;
 668         unsigned short rate_y = 0x0002;
 669         nwk_addr dest_addr16 = 0x1D1A;
 670
 671         ret = zb_mgr.zbl_ccontrol_move_color(dest_addr16, 1, rate_x,
 672                         rate_y);
 673         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 674 }
 675
 676 TEST(ZigbeeManager, CcontrolStepColor_p)
 677 {
 678         int ret = ZIGBEE_ERROR_NONE;
 679         Zigbee zb_mgr;
 680         unsigned short step_x = 0x3961;
 681         unsigned short step_y = 0x396D;
 682         unsigned short trans_time16 = 0x00C8;
 683         nwk_addr dest_addr16 = 0x1D1A;
 684
 685         ret = zb_mgr.zbl_ccontrol_step_color(dest_addr16, 1, step_x,
 686                         step_y, trans_time16);
 687         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 688 }
 689
 690 TEST(ZigbeeManager, CcontrolMoveToColorTemperature_p)
 691 {
 692         int ret = ZIGBEE_ERROR_NONE;
 693         Zigbee zb_mgr;
 694         unsigned char color_temp = 0x78;
 695         unsigned short trans_time16 = 0x00C8;
 696         nwk_addr dest_addr16 = 0x1D1A;
 697
 698         ret = zb_mgr.zbl_ccontrol_move_to_color_temperature(dest_addr16, 1, color_temp,
 699                         trans_time16);
 700         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 701 }
 702
 703 TEST(ZigbeeManager, ResetFactoryDefault_p)
 704 {
 705         int ret = ZIGBEE_ERROR_NONE;
 706         Zigbee zb_mgr;
 707         nwk_addr dest_addr16 = 0x1D1A;
 708
 709         ret = zb_mgr.zbl_reset_factory_default(dest_addr16, 1);
 710         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 711 }
 712
 713 TEST(ZigbeeManager, Identify_p)
 714 {
 715         int ret = ZIGBEE_ERROR_NONE;
 716         Zigbee zb_mgr;
 717         unsigned short identify_time = 10;
 718         nwk_addr dest_addr16 = 0x1D1A;
 719
 720         ret = zb_mgr.zbl_identify(dest_addr16, 1, identify_time);
 721         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 722 }
 723
 724 TEST(ZigbeeManager, Identify_query_p)
 725 {
 726         int ret = ZIGBEE_ERROR_NONE;
 727         Zigbee zb_mgr;
 728         nwk_addr dest_addr16 = 0x1D1A;
 729
 730         ret = zb_mgr.zbl_identify_query(dest_addr16, 1);
 731         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 732 }
 733
 734 TEST(ZigbeeManager, AddGroup_p)
 735 {
 736         int ret = ZIGBEE_ERROR_NONE;
 737         Zigbee zb_mgr;
 738         nwk_addr dest_addr16 = 0x1D1A;
 739
 740         ret = zb_mgr.zbl_add_group(dest_addr16, 1, 0x0002, "6grpone");
 741         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 742 }
 743
 744 TEST(ZigbeeManager, ViewGroup_p)
 745 {
 746         int ret = ZIGBEE_ERROR_NONE;
 747         Zigbee zb_mgr;
 748         nwk_addr dest_addr16 = 0x1D1A;
 749
 750         ret = zb_mgr.zbl_view_group(dest_addr16, 1, 0x0002);
 751         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 752 }
 753
 754 TEST(ZigbeeManager, GetGroupMembership_p)
 755 {
 756         int ret = ZIGBEE_ERROR_NONE;
 757         Zigbee zb_mgr;
 758         nwk_addr dest_addr16 = 0x1D1A;
 759         unsigned short group_list[2] = { 0x0002, 0x0003 };
 760
 761         ret = zb_mgr.zbl_group_get_group_membership(dest_addr16, 1,
 762                         2, group_list);
 763         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 764 }
 765
 766 TEST(ZigbeeManager, RemoveGroup_p)
 767 {
 768         int ret = ZIGBEE_ERROR_NONE;
 769         Zigbee zb_mgr;
 770         nwk_addr dest_addr16 = 0x1D1A;
 771
 772         ret = zb_mgr.zbl_remove_group(dest_addr16, 1, 0x0002);
 773         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 774 }
 775
 776 TEST(ZigbeeManager, RemoveAllGroup_p)
 777 {
 778         int ret = ZIGBEE_ERROR_NONE;
 779         Zigbee zb_mgr;
 780         nwk_addr dest_addr16 = 0x1D1A;
 781
 782         ret = zb_mgr.zbl_remove_all_group(dest_addr16, 1);
 783         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 784 }
 785
 786 TEST(ZigbeeManager, AddGroupIfIdentifying_p)
 787 {
 788         int ret = ZIGBEE_ERROR_NONE;
 789         Zigbee zb_mgr;
 790         nwk_addr dest_addr16 = 0x1D1A;
 791
 792         ret = zb_mgr.zbl_add_group_if_identifying(dest_addr16, 1, 0x0002,
 793                         "6grpone");
 794         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 795 }
 796
 797 TEST(ZigbeeManager, LevelControlMoveToLevel_p)
 798 {
 799         int ret = ZIGBEE_ERROR_NONE;
 800         Zigbee zb_mgr;
 801         nwk_addr dest_addr16 = 0x1D1A;
 802         unsigned short trans_time16 = 0x00C8;
 803
 804         ret = zb_mgr.zbl_level_control_move_to_level(dest_addr16, 1, 0x01,
 805                         trans_time16);
 806         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 807 }
 808
 809 TEST(ZigbeeManager, LevelControlMove_p)
 810 {
 811         int ret = ZIGBEE_ERROR_NONE;
 812         Zigbee zb_mgr;
 813         nwk_addr dest_addr16 = 0x1D1A;
 814
 815         ret = zb_mgr.zbl_level_control_move(dest_addr16, 1, 0x03, 2);
 816         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 817 }
 818
 819 TEST(ZigbeeManager, LevelControlSetp_p)
 820 {
 821         int ret = ZIGBEE_ERROR_NONE;
 822         Zigbee zb_mgr;
 823         nwk_addr dest_addr16 = 0x1D1A;
 824
 825         ret = zb_mgr.zbl_level_control_step(dest_addr16, 1, 0x03, 0x20,
 826                         0x00C8);
 827         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 828 }
 829
 830 TEST(ZigbeeManager, LevelControlStop_p)
 831 {
 832         int ret = ZIGBEE_ERROR_NONE;
 833         Zigbee zb_mgr;
 834         nwk_addr dest_addr16 = 0x1D1A;
 835
 836         ret = zb_mgr.zbl_level_control_stop(dest_addr16, 1);
 837         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 838 }
 839
 840 TEST(ZigbeeManager, LevelControlMoveToLevelWithOnOff_p)
 841 {
 842         int ret = ZIGBEE_ERROR_NONE;
 843         Zigbee zb_mgr;
 844         nwk_addr dest_addr16 = 0x1D1A;
 845
 846         ret = zb_mgr.zbl_level_control_move_to_level_with_on_off(dest_addr16, 1, 0x02,
 847                         0x00C8);
 848         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 849 }
 850
 851 TEST(ZigbeeManager, LevelControlMoveWithOnOff_p)
 852 {
 853         int ret = ZIGBEE_ERROR_NONE;
 854         Zigbee zb_mgr;
 855         nwk_addr dest_addr16 = 0x1D1A;
 856
 857         ret = zb_mgr.zbl_level_control_move_with_on_off(dest_addr16, 1, 0x03, 2);
 858         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 859 }
 860
 861 TEST(ZigbeeManager, LevelControlSetpWithOnOff_p)
 862 {
 863         int ret = ZIGBEE_ERROR_NONE;
 864         Zigbee zb_mgr;
 865         nwk_addr dest_addr16 = 0x1D1A;
 866
 867         ret = zb_mgr.zbl_level_control_step_with_on_off(dest_addr16, 1, 0x03, 0x20,
 868                         0x00C8);
 869         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 870 }
 871
 872 TEST(ZigbeeManager, OnOffSet_p)
 873 {
 874         int ret = ZIGBEE_ERROR_NONE;
 875         Zigbee zb_mgr;
 876         nwk_addr dest_addr16 = 0x1D1A;
 877
 878         ret = zb_mgr.zbl_onoff_set(dest_addr16, 1, 0x01);
 879         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 880 }
 881
 882 TEST(ZigbeeManager, ZoneEnrollResponse_p)
 883 {
 884         int ret = ZIGBEE_ERROR_NONE;
 885         Zigbee zb_mgr;
 886         nwk_addr dest_addr16 = 0x1D1A;
 887         unsigned char enroll_response_code = 10;
 888         unsigned char zone_id = 10;
 889
 890         ret = zb_mgr.zbl_zone_enroll_response(dest_addr16, 1, enroll_response_code,
 891                         zone_id);
 892         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 893 }
 894
 895 TEST(ZigbeeManager, PollcontrolCheckinResponse_p)
 896 {
 897         int ret = ZIGBEE_ERROR_NONE;
 898         Zigbee zb_mgr;
 899         nwk_addr dest_addr16 = 0x1D1A;
 900
 901         ret = zb_mgr.zbl_pollcontrol_check_in_response(dest_addr16, 1, 0x01, 0x00C8);
 902         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 903 }
 904
 905 TEST(ZigbeeManager, PollcontrolFastPollStop_p)
 906 {
 907         int ret = ZIGBEE_ERROR_NONE;
 908         Zigbee zb_mgr;
 909         nwk_addr dest_addr16 = 0x1D1A;
 910
 911         ret = zb_mgr.zbl_pollcontrol_fast_poll_stop(dest_addr16, 1);
 912         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 913 }
 914
 915 TEST(ZigbeeManager, PollcontrolSetShortPollInterval_p)
 916 {
 917         int ret = ZIGBEE_ERROR_NONE;
 918         Zigbee zb_mgr;
 919         nwk_addr dest_addr16 = 0x1D1A;
 920
 921         ret = zb_mgr.zbl_pollcontrol_set_short_poll_interval(dest_addr16, 1, 5);
 922         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 923 }
 924
 925 TEST(ZigbeeManager, PollcontrolSetLongPollInterval_p)
 926 {
 927         int ret = ZIGBEE_ERROR_NONE;
 928         Zigbee zb_mgr;
 929         nwk_addr dest_addr16 = 0x1D1A;
 930
 931         ret = zb_mgr.zbl_pollcontrol_set_long_poll_interval(dest_addr16, 1, 10);
 932         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 933 }
 934
 935 TEST(ZigbeeManager, AddScene_p)
 936 {
 937         int ret = ZIGBEE_ERROR_NONE;
 938         Zigbee zb_mgr;
 939         nwk_addr dest_addr16 = 0x1D1A;
 940         const char ext_field_set[] = {0x00, 0x06, 0x01, 0x00};
 941
 942         ret = zb_mgr.zbl_add_scene(dest_addr16, 1, 0x0002, 0x01, 0x0000,
 943                         "6scnone", 4, ext_field_set);
 944         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 945 }
 946
 947 TEST(ZigbeeManager, ViewScene_p)
 948 {
 949         int ret = ZIGBEE_ERROR_NONE;
 950         Zigbee zb_mgr;
 951         nwk_addr dest_addr16 = 0x1D1A;
 952
 953         ret = zb_mgr.zbl_view_scene(dest_addr16, 1, 0x0002, 0x01);
 954         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 955 }
 956
 957 TEST(ZigbeeManager, RemoveScene_p)
 958 {
 959         int ret = ZIGBEE_ERROR_NONE;
 960         Zigbee zb_mgr;
 961         nwk_addr dest_addr16 = 0x1D1A;
 962
 963         ret = zb_mgr.zbl_remove_scene(dest_addr16, 1, 0x0002, 0x01);
 964         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 965 }
 966
 967 TEST(ZigbeeManager, RemoveAllScene_p)
 968 {
 969         int ret = ZIGBEE_ERROR_NONE;
 970         Zigbee zb_mgr;
 971         nwk_addr dest_addr16 = 0x1D1A;
 972
 973         ret = zb_mgr.zbl_remove_all_scene(dest_addr16, 1, 0x0002);
 974         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 975 }
 976
 977 TEST(ZigbeeManager, StoreScene_p)
 978 {
 979         int ret = ZIGBEE_ERROR_NONE;
 980         Zigbee zb_mgr;
 981         nwk_addr dest_addr16 = 0x1D1A;
 982
 983         ret = zb_mgr.zbl_store_scene(dest_addr16, 1, 0x0002, 0x01);
 984         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 985 }
 986
 987 TEST(ZigbeeManager, RecallScene_p)
 988 {
 989         int ret = ZIGBEE_ERROR_NONE;
 990         Zigbee zb_mgr;
 991         nwk_addr dest_addr16 = 0x1D1A;
 992
 993         ret = zb_mgr.zbl_recall_scene(dest_addr16, 1, 0x0002, 0x01);
 994         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
 995 }
 996
 997 TEST(ZigbeeManager, GetSceneMembership_p)
 998 {
 999         int ret = ZIGBEE_ERROR_NONE;
1000         Zigbee zb_mgr;
1001         nwk_addr dest_addr16 = 0x1D1A;
1002
1003         ret = zb_mgr.zbl_get_scene_membership(dest_addr16, 1, 0x0002);
1004         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
1005 }
1006
1007 TEST(ZigbeeManager, ThermostatAdjustSetpoint_p)
1008 {
1009         int ret = ZIGBEE_ERROR_NONE;
1010         Zigbee zb_mgr;
1011         nwk_addr dest_addr16 = 0x1D1A;
1012         unsigned char mode = 0x00;
1013         unsigned char amount = 0x01;
1014
1015         ret = zb_mgr.zbl_thermostat_adjust_setpoint(dest_addr16, 1, mode,
1016                         amount);
1017         EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
1018 }
1019
1020 int main(int argc, char **argv)
1021 {
1022         InitGoogleTest(&argc, argv);
1023         return RUN_ALL_TESTS();
1024 }