2 * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
26 using ::testing::InitGoogleTest;
27 using ::testing::Test;
28 using ::testing::TestCase;
30 TEST(ZigbeeManager, Enable_p)
32 int ret = ZIGBEE_ERROR_NONE;
35 ret = zb_mgr.zbl_enable();
36 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
39 TEST(ZigbeeManager, Disable_p)
41 int ret = ZIGBEE_ERROR_NONE;
44 ret = zb_mgr.zbl_disable();
45 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
48 TEST(ZigbeeManager, IsEnable_p)
50 int ret = ZIGBEE_ERROR_NONE;
54 ret = zb_mgr.zbl_is_enable(&state);
55 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
58 TEST(ZigbeeManager, Enable_p1)
60 int ret = ZIGBEE_ERROR_NONE;
63 ret = zb_mgr.zbl_enable();
64 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
67 TEST(ZigbeeManager, HwReset_p)
69 int ret = ZIGBEE_ERROR_NONE;
72 ret = zb_mgr.zbl_hw_reset();
73 EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_IO_ERROR == ret) );
76 TEST(ZigbeeManager, GetNetworkInfo_p)
78 int ret = ZIGBEE_ERROR_NONE;
81 ret = zb_mgr.zbl_get_network_info();
82 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
85 TEST(ZigbeeManager, GetControllerMacAddr_p)
87 int ret = ZIGBEE_ERROR_NONE;
91 ret = zb_mgr.zbl_get_controller_mac_address(mac);
92 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
95 TEST(ZigbeeManager, GetClusterList_p)
97 int ret = ZIGBEE_ERROR_NONE;
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 };
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);
112 TEST(ZigbeeManager, GetEndPointList_p)
114 int ret = ZIGBEE_ERROR_NONE;
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 };
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) );
125 TEST(ZigbeeManager, ApiGetNodeType_p)
127 int ret = ZIGBEE_ERROR_NONE;
129 ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
130 0x02, 0xF2, 0x58, 0x5B };
132 ret = zb_mgr.zbl_api_get_node_type(dest_addr64);
133 EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
136 TEST(ZigbeeManager, GetAllDeviceInfo_p)
138 int ret = ZIGBEE_ERROR_NONE;
141 ret = zb_mgr.zbl_get_all_device_info();
142 EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
145 TEST(ZigbeeManager, CoexStart_p)
147 int ret = ZIGBEE_ERROR_NONE;
149 unsigned char channel = 11;
151 ret = zb_mgr.zbl_coex_start(channel);
152 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
155 TEST(ZigbeeManager, CoexStop_p)
157 int ret = ZIGBEE_ERROR_NONE;
160 ret = zb_mgr.zbl_coex_stop();
161 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
164 TEST(ZigbeeManager, FormNetwork_p)
166 int ret = ZIGBEE_ERROR_NONE;
169 ret = zb_mgr.zbl_form_network();
170 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
173 TEST(ZigbeeManager, DisableNetwork_p)
175 int ret = ZIGBEE_ERROR_NONE;
178 ret = zb_mgr.zbl_disable_network();
179 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
182 TEST(ZigbeeManager, LeaveDevice_p)
184 int ret = ZIGBEE_ERROR_NONE;
186 ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
187 0x02, 0xF2, 0x58, 0x5B };
188 bool remove_children = true;
191 ret = zb_mgr.zbl_leave_device(dest_addr64, remove_children,
193 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
196 TEST(ZigbeeManager, PermitJoin_p)
198 int ret = ZIGBEE_ERROR_NONE;
200 unsigned char timeout = 90;
201 bool broadcast = true;
203 ret = zb_mgr.zbl_permit_join(timeout, broadcast);
204 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
207 TEST(ZigbeeManager, NwkAddrReq_p)
209 int ret = ZIGBEE_ERROR_NONE;
211 ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
212 0x02, 0xF2, 0x58, 0x5B };
214 ret = zb_mgr.zbl_nwk_addr_req(dest_addr64, 0x00, 0x00);
215 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
218 TEST(ZigbeeManager, IeeeAddrReq_p)
220 int ret = ZIGBEE_ERROR_NONE;
222 nwk_addr dest_addr16 = 0x1D1A;
224 ret = zb_mgr.zbl_ieee_addr_req(dest_addr16);
225 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
228 TEST(ZigbeeManager, ActiveEp_p)
230 int ret = ZIGBEE_ERROR_NONE;
232 nwk_addr dest_addr16 = 0x1D1A;
234 ret = zb_mgr.zbl_active_ep(dest_addr16);
235 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
238 TEST(ZigbeeManager, SimpleDescReq_p)
240 int ret = ZIGBEE_ERROR_NONE;
242 nwk_addr dest_addr16 = 0x1D1A;
244 ret = zb_mgr.zbl_simple_desc_req(dest_addr16, 1);
245 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
248 TEST(ZigbeeManager, MatchDescReq_p)
250 int ret = ZIGBEE_ERROR_NONE;
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 };
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);
263 TEST(ZigbeeManager, NodeDescReq_p)
265 int ret = ZIGBEE_ERROR_NONE;
267 nwk_addr dest_addr16 = 0x1D1A;
269 ret = zb_mgr.zbl_node_desc_req(dest_addr16);
270 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
273 TEST(ZigbeeManager, PowerDescReq_p)
275 int ret = ZIGBEE_ERROR_NONE;
277 nwk_addr dest_addr16 = 0x1D1A;
279 ret = zb_mgr.zbl_power_desc_req(dest_addr16);
280 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
283 TEST(ZigbeeManager, ComplexDescReq_p)
285 int ret = ZIGBEE_ERROR_NONE;
287 nwk_addr dest_addr16 = 0x1D1A;
289 ret = zb_mgr.zbl_complex_desc_req(dest_addr16);
290 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
293 TEST(ZigbeeManager, UserDescReq_p)
295 int ret = ZIGBEE_ERROR_NONE;
297 nwk_addr dest_addr16 = 0x1D1A;
299 ret = zb_mgr.zbl_user_desc_req(dest_addr16);
300 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
303 TEST(ZigbeeManager, UserDescSet_p)
305 int ret = ZIGBEE_ERROR_NONE;
307 nwk_addr dest_addr16 = 0x1D1A;
309 ret = zb_mgr.zbl_user_desc_set(dest_addr16, 4, (unsigned char *)"test");
310 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
313 TEST(ZigbeeManager, DeviceAnnce_p)
315 int ret = ZIGBEE_ERROR_NONE;
317 nwk_addr st_addr16 = 0x708B;
318 ieee_addr st_addr64 = { 0x00, 0x0D, 0x6F, 0x00,
319 0x04, 0x2B, 0xBE, 0x14 };
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);
328 TEST(ZigbeeManager, BindReq_p)
330 int ret = ZIGBEE_ERROR_NONE;
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 };
338 ret = zb_mgr.zbl_bind_req(dest_addr16, sj_addr64, 1, 0x0006,
339 co_addr64, 0x03, 0x0004, 1);
341 EXPECT_TRUE( (ZIGBEE_ERROR_NONE == ret) || (ZIGBEE_ERROR_NO_DATA == ret) );
344 TEST(ZigbeeManager, UbindReq_p)
346 int ret = ZIGBEE_ERROR_NONE;
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 };
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);
359 TEST(ZigbeeManager, MgmtNwkDiscReq_p)
361 int ret = ZIGBEE_ERROR_NONE;
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;
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);
374 TEST(ZigbeeManager, MgmtNwkUpdateReq_p)
376 int ret = ZIGBEE_ERROR_NONE;
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;
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);
389 TEST(ZigbeeManager, MgmtLqiReq_p)
391 int ret = ZIGBEE_ERROR_NONE;
393 nwk_addr dest_addr16 = 0x1D1A;
394 unsigned char start_idx = 0;
396 ret = zb_mgr.zbl_mgmt_lqi_req(dest_addr16, start_idx);
397 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
400 TEST(ZigbeeManager, MgmtRtgReq_p)
402 int ret = ZIGBEE_ERROR_NONE;
404 nwk_addr dest_addr16 = 0x1D1A;
405 unsigned char start_idx = 0;
407 ret = zb_mgr.zbl_mgmt_rtg_req(dest_addr16, start_idx);
408 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
411 TEST(ZigbeeManager, MgmtBindReq_p)
413 int ret = ZIGBEE_ERROR_NONE;
415 nwk_addr dest_addr16 = 0x1D1A;
416 unsigned char start_idx = 0;
418 ret = zb_mgr.zbl_mgmt_bind_req(dest_addr16, start_idx);
419 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
422 TEST(ZigbeeManager, MgmtLeaveDevice_p)
424 int ret = ZIGBEE_ERROR_NONE;
426 bool remove_children = true;
428 ieee_addr dest_addr64 = { 0x00, 0x12, 0x4B, 0x00,
429 0x02, 0xF2, 0x58, 0x5B };
431 ret = zb_mgr.zbl_mgmt_leave_device(dest_addr64, remove_children, rejoin);
432 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
435 TEST(ZigbeeManager, MgmtPermitJoiningReq_p)
437 int ret = ZIGBEE_ERROR_NONE;
439 unsigned char permit_duration = 1;
440 unsigned char tc_significance = 1;
441 nwk_addr dest_addr16 = 0x1D1A;
443 ret = zb_mgr.zbl_mgmt_permit_joining_req(dest_addr16, permit_duration,
445 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
448 TEST(ZigbeeManager, ApsSend_p)
450 int ret = ZIGBEE_ERROR_NONE;
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;
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);
470 TEST(ZigbeeManager, ZclSend_p)
472 int ret = ZIGBEE_ERROR_NONE;
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;
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);
489 TEST(ZigbeeManager, SendToLocal_p)
491 int ret = ZIGBEE_ERROR_NONE;
493 unsigned short length = 4;
494 unsigned char data[4] = { 0x00, 0x01, 0x02, 0x03 };
496 ret = zb_mgr.zbl_send_to_local(length, data);
497 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
500 TEST(ZigbeeManager, DiscoverCmdsGen_p)
502 int ret = ZIGBEE_ERROR_NONE;
504 nwk_addr dest_addr16 = 0x1D1A;
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);
511 TEST(ZigbeeManager, DiscoverAttrExt_p)
513 int ret = ZIGBEE_ERROR_NONE;
515 nwk_addr dest_addr16 = 0x1D1A;
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);
522 TEST(ZigbeeManager, ResetAlarm_p)
524 int ret = ZIGBEE_ERROR_NONE;
526 unsigned char alarm_code = 0x01;
527 nwk_addr dest_addr16 = 0x1D1A;
529 ret = zb_mgr.zbl_reset_alarm(dest_addr16, 1, alarm_code,
531 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
534 TEST(ZigbeeManager, GetAlarm_p)
536 int ret = ZIGBEE_ERROR_NONE;
538 nwk_addr dest_addr16 = 0x1D1A;
540 ret = zb_mgr.zbl_get_alarm(dest_addr16, 1);
541 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
544 TEST(ZigbeeManager, ResetAllAlarmLog_p)
546 int ret = ZIGBEE_ERROR_NONE;
548 nwk_addr dest_addr16 = 0x1D1A;
550 ret = zb_mgr.zbl_reset_all_alarm_log(dest_addr16, 1);
551 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
554 TEST(ZigbeeManager, CcontrolMoveToHue_p)
556 int ret = ZIGBEE_ERROR_NONE;
558 unsigned char move_hue = 0x20;
559 unsigned char direction = 0x00;
560 unsigned short trans_time16 = 0x00C8;
561 nwk_addr dest_addr16 = 0x1D1A;
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);
568 TEST(ZigbeeManager, CcontrolMoveHue_p)
570 int ret = ZIGBEE_ERROR_NONE;
572 unsigned char move_mode = 0x03;
573 unsigned char color_rate = 2;
574 nwk_addr dest_addr16 = 0x1D1A;
576 ret = zb_mgr.zbl_ccontrol_move_hue(dest_addr16, 1, move_mode,
578 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
581 TEST(ZigbeeManager, CcontrolStepHue_p)
583 int ret = ZIGBEE_ERROR_NONE;
585 unsigned char step_mode = 0x03;
586 unsigned char step_size = 0x20;
587 unsigned char trans_time8 = 0x0A;
588 nwk_addr dest_addr16 = 0x1D1A;
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);
595 TEST(ZigbeeManager, CcontrolMoveToSaturation_p)
597 int ret = ZIGBEE_ERROR_NONE;
599 unsigned char saturation = 0x0A;
600 unsigned char trans_time16 = 0x00C8;
601 nwk_addr dest_addr16 = 0x1D1A;
603 ret = zb_mgr.zbl_ccontrol_move_to_saturation(dest_addr16, 1, saturation,
605 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
608 TEST(ZigbeeManager, CcontrolMoveSaturation_p)
610 int ret = ZIGBEE_ERROR_NONE;
612 unsigned char move_mode = 0x03;
613 unsigned char color_rate = 2;
614 nwk_addr dest_addr16 = 0x1D1A;
616 ret = zb_mgr.zbl_ccontrol_move_saturation(dest_addr16, 1, move_mode,
618 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
621 TEST(ZigbeeManager, CcontrolStepSaturation_p)
623 int ret = ZIGBEE_ERROR_NONE;
625 unsigned char step_mode = 0x03;
626 unsigned char step_size = 0x20;
627 unsigned char trans_time8 = 0x0A;
628 nwk_addr dest_addr16 = 0x1D1A;
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);
635 TEST(ZigbeeManager, CcontrolMoveToHueAndSaturation_p)
637 int ret = ZIGBEE_ERROR_NONE;
639 unsigned char move_hue = 0x20;
640 unsigned char saturation = 0x0A;
641 unsigned short trans_time16 = 0x00C8;
642 nwk_addr dest_addr16 = 0x1D1A;
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);
649 TEST(ZigbeeManager, CcontrolMoveToColor_p)
651 int ret = ZIGBEE_ERROR_NONE;
653 unsigned short color_x = 0x280A;
654 unsigned short color_y = 0x2710;
655 unsigned short trans_time16 = 0x00C8;
656 nwk_addr dest_addr16 = 0x1D1A;
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);
663 TEST(ZigbeeManager, CcontrolMoveColor_p)
665 int ret = ZIGBEE_ERROR_NONE;
667 unsigned short rate_x = 0x0002;
668 unsigned short rate_y = 0x0002;
669 nwk_addr dest_addr16 = 0x1D1A;
671 ret = zb_mgr.zbl_ccontrol_move_color(dest_addr16, 1, rate_x,
673 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
676 TEST(ZigbeeManager, CcontrolStepColor_p)
678 int ret = ZIGBEE_ERROR_NONE;
680 unsigned short step_x = 0x3961;
681 unsigned short step_y = 0x396D;
682 unsigned short trans_time16 = 0x00C8;
683 nwk_addr dest_addr16 = 0x1D1A;
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);
690 TEST(ZigbeeManager, CcontrolMoveToColorTemperature_p)
692 int ret = ZIGBEE_ERROR_NONE;
694 unsigned char color_temp = 0x78;
695 unsigned short trans_time16 = 0x00C8;
696 nwk_addr dest_addr16 = 0x1D1A;
698 ret = zb_mgr.zbl_ccontrol_move_to_color_temperature(dest_addr16, 1, color_temp,
700 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
703 TEST(ZigbeeManager, ResetFactoryDefault_p)
705 int ret = ZIGBEE_ERROR_NONE;
707 nwk_addr dest_addr16 = 0x1D1A;
709 ret = zb_mgr.zbl_reset_factory_default(dest_addr16, 1);
710 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
713 TEST(ZigbeeManager, Identify_p)
715 int ret = ZIGBEE_ERROR_NONE;
717 unsigned short identify_time = 10;
718 nwk_addr dest_addr16 = 0x1D1A;
720 ret = zb_mgr.zbl_identify(dest_addr16, 1, identify_time);
721 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
724 TEST(ZigbeeManager, Identify_query_p)
726 int ret = ZIGBEE_ERROR_NONE;
728 nwk_addr dest_addr16 = 0x1D1A;
730 ret = zb_mgr.zbl_identify_query(dest_addr16, 1);
731 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
734 TEST(ZigbeeManager, AddGroup_p)
736 int ret = ZIGBEE_ERROR_NONE;
738 nwk_addr dest_addr16 = 0x1D1A;
740 ret = zb_mgr.zbl_add_group(dest_addr16, 1, 0x0002, "6grpone");
741 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
744 TEST(ZigbeeManager, ViewGroup_p)
746 int ret = ZIGBEE_ERROR_NONE;
748 nwk_addr dest_addr16 = 0x1D1A;
750 ret = zb_mgr.zbl_view_group(dest_addr16, 1, 0x0002);
751 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
754 TEST(ZigbeeManager, GetGroupMembership_p)
756 int ret = ZIGBEE_ERROR_NONE;
758 nwk_addr dest_addr16 = 0x1D1A;
759 unsigned short group_list[2] = { 0x0002, 0x0003 };
761 ret = zb_mgr.zbl_group_get_group_membership(dest_addr16, 1,
763 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
766 TEST(ZigbeeManager, RemoveGroup_p)
768 int ret = ZIGBEE_ERROR_NONE;
770 nwk_addr dest_addr16 = 0x1D1A;
772 ret = zb_mgr.zbl_remove_group(dest_addr16, 1, 0x0002);
773 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
776 TEST(ZigbeeManager, RemoveAllGroup_p)
778 int ret = ZIGBEE_ERROR_NONE;
780 nwk_addr dest_addr16 = 0x1D1A;
782 ret = zb_mgr.zbl_remove_all_group(dest_addr16, 1);
783 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
786 TEST(ZigbeeManager, AddGroupIfIdentifying_p)
788 int ret = ZIGBEE_ERROR_NONE;
790 nwk_addr dest_addr16 = 0x1D1A;
792 ret = zb_mgr.zbl_add_group_if_identifying(dest_addr16, 1, 0x0002,
794 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
797 TEST(ZigbeeManager, LevelControlMoveToLevel_p)
799 int ret = ZIGBEE_ERROR_NONE;
801 nwk_addr dest_addr16 = 0x1D1A;
802 unsigned short trans_time16 = 0x00C8;
804 ret = zb_mgr.zbl_level_control_move_to_level(dest_addr16, 1, 0x01,
806 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
809 TEST(ZigbeeManager, LevelControlMove_p)
811 int ret = ZIGBEE_ERROR_NONE;
813 nwk_addr dest_addr16 = 0x1D1A;
815 ret = zb_mgr.zbl_level_control_move(dest_addr16, 1, 0x03, 2);
816 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
819 TEST(ZigbeeManager, LevelControlSetp_p)
821 int ret = ZIGBEE_ERROR_NONE;
823 nwk_addr dest_addr16 = 0x1D1A;
825 ret = zb_mgr.zbl_level_control_step(dest_addr16, 1, 0x03, 0x20,
827 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
830 TEST(ZigbeeManager, LevelControlStop_p)
832 int ret = ZIGBEE_ERROR_NONE;
834 nwk_addr dest_addr16 = 0x1D1A;
836 ret = zb_mgr.zbl_level_control_stop(dest_addr16, 1);
837 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
840 TEST(ZigbeeManager, LevelControlMoveToLevelWithOnOff_p)
842 int ret = ZIGBEE_ERROR_NONE;
844 nwk_addr dest_addr16 = 0x1D1A;
846 ret = zb_mgr.zbl_level_control_move_to_level_with_on_off(dest_addr16, 1, 0x02,
848 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
851 TEST(ZigbeeManager, LevelControlMoveWithOnOff_p)
853 int ret = ZIGBEE_ERROR_NONE;
855 nwk_addr dest_addr16 = 0x1D1A;
857 ret = zb_mgr.zbl_level_control_move_with_on_off(dest_addr16, 1, 0x03, 2);
858 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
861 TEST(ZigbeeManager, LevelControlSetpWithOnOff_p)
863 int ret = ZIGBEE_ERROR_NONE;
865 nwk_addr dest_addr16 = 0x1D1A;
867 ret = zb_mgr.zbl_level_control_step_with_on_off(dest_addr16, 1, 0x03, 0x20,
869 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
872 TEST(ZigbeeManager, OnOffSet_p)
874 int ret = ZIGBEE_ERROR_NONE;
876 nwk_addr dest_addr16 = 0x1D1A;
878 ret = zb_mgr.zbl_onoff_set(dest_addr16, 1, 0x01);
879 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
882 TEST(ZigbeeManager, ZoneEnrollResponse_p)
884 int ret = ZIGBEE_ERROR_NONE;
886 nwk_addr dest_addr16 = 0x1D1A;
887 unsigned char enroll_response_code = 10;
888 unsigned char zone_id = 10;
890 ret = zb_mgr.zbl_zone_enroll_response(dest_addr16, 1, enroll_response_code,
892 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
895 TEST(ZigbeeManager, PollcontrolCheckinResponse_p)
897 int ret = ZIGBEE_ERROR_NONE;
899 nwk_addr dest_addr16 = 0x1D1A;
901 ret = zb_mgr.zbl_pollcontrol_check_in_response(dest_addr16, 1, 0x01, 0x00C8);
902 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
905 TEST(ZigbeeManager, PollcontrolFastPollStop_p)
907 int ret = ZIGBEE_ERROR_NONE;
909 nwk_addr dest_addr16 = 0x1D1A;
911 ret = zb_mgr.zbl_pollcontrol_fast_poll_stop(dest_addr16, 1);
912 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
915 TEST(ZigbeeManager, PollcontrolSetShortPollInterval_p)
917 int ret = ZIGBEE_ERROR_NONE;
919 nwk_addr dest_addr16 = 0x1D1A;
921 ret = zb_mgr.zbl_pollcontrol_set_short_poll_interval(dest_addr16, 1, 5);
922 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
925 TEST(ZigbeeManager, PollcontrolSetLongPollInterval_p)
927 int ret = ZIGBEE_ERROR_NONE;
929 nwk_addr dest_addr16 = 0x1D1A;
931 ret = zb_mgr.zbl_pollcontrol_set_long_poll_interval(dest_addr16, 1, 10);
932 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
935 TEST(ZigbeeManager, AddScene_p)
937 int ret = ZIGBEE_ERROR_NONE;
939 nwk_addr dest_addr16 = 0x1D1A;
940 const char ext_field_set[] = {0x00, 0x06, 0x01, 0x00};
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);
947 TEST(ZigbeeManager, ViewScene_p)
949 int ret = ZIGBEE_ERROR_NONE;
951 nwk_addr dest_addr16 = 0x1D1A;
953 ret = zb_mgr.zbl_view_scene(dest_addr16, 1, 0x0002, 0x01);
954 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
957 TEST(ZigbeeManager, RemoveScene_p)
959 int ret = ZIGBEE_ERROR_NONE;
961 nwk_addr dest_addr16 = 0x1D1A;
963 ret = zb_mgr.zbl_remove_scene(dest_addr16, 1, 0x0002, 0x01);
964 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
967 TEST(ZigbeeManager, RemoveAllScene_p)
969 int ret = ZIGBEE_ERROR_NONE;
971 nwk_addr dest_addr16 = 0x1D1A;
973 ret = zb_mgr.zbl_remove_all_scene(dest_addr16, 1, 0x0002);
974 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
977 TEST(ZigbeeManager, StoreScene_p)
979 int ret = ZIGBEE_ERROR_NONE;
981 nwk_addr dest_addr16 = 0x1D1A;
983 ret = zb_mgr.zbl_store_scene(dest_addr16, 1, 0x0002, 0x01);
984 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
987 TEST(ZigbeeManager, RecallScene_p)
989 int ret = ZIGBEE_ERROR_NONE;
991 nwk_addr dest_addr16 = 0x1D1A;
993 ret = zb_mgr.zbl_recall_scene(dest_addr16, 1, 0x0002, 0x01);
994 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
997 TEST(ZigbeeManager, GetSceneMembership_p)
999 int ret = ZIGBEE_ERROR_NONE;
1001 nwk_addr dest_addr16 = 0x1D1A;
1003 ret = zb_mgr.zbl_get_scene_membership(dest_addr16, 1, 0x0002);
1004 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
1007 TEST(ZigbeeManager, ThermostatAdjustSetpoint_p)
1009 int ret = ZIGBEE_ERROR_NONE;
1011 nwk_addr dest_addr16 = 0x1D1A;
1012 unsigned char mode = 0x00;
1013 unsigned char amount = 0x01;
1015 ret = zb_mgr.zbl_thermostat_adjust_setpoint(dest_addr16, 1, mode,
1017 EXPECT_EQ(ZIGBEE_ERROR_NONE, ret);
1020 int main(int argc, char **argv)
1022 InitGoogleTest(&argc, argv);
1023 return RUN_ALL_TESTS();