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 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <gmock/gmock.h>
  19 #include <gtest/gtest.h>
  20 #include <unistd.h>
  21
  22 #include "unittest.h"
  23 #include "method_injector.h"
  24 #include "event_injector.h"
  25 #include "wifi-direct-ipc.h"
  26 #include "wifi-direct-manager.h"
  27 #include "wifi-direct-method.h"
  28 #include "wifi-direct-state.h"
  29 #include "wifi-direct-oem.h"
  30 #include "wifi-direct-event.h"
  31 #include "wifi-direct-group.h"
  32 #include "wifi-direct-log.h"
  33
  34 using ::testing::EmptyTestEventListener;
  35 using ::testing::InitGoogleTest;
  36 using ::testing::Test;
  37 using ::testing::TestCase;
  38 using ::testing::TestEventListeners;
  39 using ::testing::TestInfo;
  40 using ::testing::TestPartResult;
  41 using ::testing::UnitTest;
  42
  43 #define CHECK_WFD_MGR_STATE(manager, expected_state)\
  44         do {\
  45                 int res = 0;\
  46                 int state = 0;\
  47                 res = wfd_state_get((manager), &state);\
  48                 ASSERT_EQ(0, res);\
  49                 ASSERT_EQ((expected_state), state);\
  50                 } while (0);
  51
  52 #define INIT_WFD_MGR(manager)\
  53         do {\
  54                 wfd_manager_s *manager_null = NULL;\
  55                 int res = 0;\
  56                 res = wfd_manager_load();\
  57                 ASSERT_EQ(0, res);\
  58                 ASSERT_NE(manager_null, wfd_get_manager());\
  59                 CHECK_WFD_MGR_STATE(wfd_get_manager(), WIFI_DIRECT_STATE_DEACTIVATED);\
  60                 } while (0);
  61
  62 TEST(wfd_mgr_activate_deactivate, activate_hanlder_Positive)
  63 {
  64         wfd_manager_s * manager = NULL;
  65
  66         INIT_WFD_MGR(manager);
  67         manager = wfd_get_manager();
  68
  69         activate_handler(NULL, NULL);
  70         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
  71
  72         deactivate_handler(NULL, NULL);
  73         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
  74
  75         wfd_manager_unload();
  76 }
  77
  78 TEST(wfd_mgr_activate_deactivate, activate_hanlder_Negative)
  79 {
  80         wfd_manager_s * manager = NULL;
  81         int state = 0;
  82         int ret = 0;
  83
  84         manager = wfd_get_manager();
  85         activate_handler(NULL, NULL);
  86         ret = wfd_state_get(NULL, &state);
  87         ASSERT_EQ(-1, ret);
  88 }
  89
  90 TEST(wfd_mgr_get, get_info_Positive )
  91 {
  92         wfd_manager_s * manager = NULL;
  93
  94         INIT_WFD_MGR(manager);
  95         manager = wfd_get_manager();
  96
  97         activate_handler(NULL, NULL);
  98         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
  99
 100         MethodInjector *group_create_method = new MethodInjector;
 101         create_group_handler(group_create_method->CreateGroup(), NULL);
 102
 103         EventInjector *group_started_event = new EventInjector;
 104         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
 105         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 106
 107         get_state_handler(NULL, NULL);
 108         get_supported_wps_mode_handler(NULL, NULL);
 109         get_local_wps_mode_handler(NULL, NULL);
 110         is_listening_only_handler(NULL, NULL);
 111         is_discoverable_handler(NULL, NULL);
 112         is_group_owner_handler(NULL, NULL);
 113         is_auto_group_handler(NULL, NULL);
 114         get_operating_channel_handler(NULL, NULL);
 115         activate_pushbutton_handler(NULL, NULL);
 116         get_ip_address_handler(NULL, NULL);
 117         get_mac_address_handler(NULL, NULL);
 118         get_interface_name_handler(NULL, NULL);
 119         get_subnet_mask_handler(NULL, NULL);
 120         get_gateway_handler(NULL, NULL);
 121         get_primary_dev_type_handler(NULL, NULL);
 122         get_secondary_dev_type_handler(NULL, NULL);
 123
 124         destroy_group_handler(NULL, NULL);
 125
 126         EventInjector *group_destroy_event = new EventInjector;
 127         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
 128         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 129
 130         deactivate_handler(NULL, NULL);
 131         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 132
 133         wfd_manager_unload();
 134
 135         delete group_create_method;
 136         delete group_started_event;
 137         delete group_destroy_event;
 138 }
 139
 140 TEST(wfd_mgr_get, is_listening_only_handler_Negative)
 141 {
 142         is_listening_only_handler(NULL, NULL);
 143 }
 144
 145 TEST(wfd_mgr_get, is_group_owner_handler_Negative)
 146 {
 147         is_group_owner_handler(NULL, NULL);
 148 }
 149
 150 TEST(wfd_mgr_get, is_discoverable_handler_Negative)
 151 {
 152         is_discoverable_handler(NULL, NULL);
 153 }
 154
 155 TEST(wfd_mgr_get, is_auto_group_handler_Negative)
 156 {
 157         is_auto_group_handler(NULL, NULL);
 158 }
 159
 160 TEST(wfd_mgr_get, get_operating_channel_handler_Negative1)
 161 {
 162         get_operating_channel_handler(NULL, NULL);
 163 }
 164
 165 TEST(wfd_mgr_get, get_operating_channel_handler_Negative2)
 166 {
 167         wfd_manager_s * manager = NULL;
 168
 169         INIT_WFD_MGR(manager);
 170         manager = wfd_get_manager();
 171
 172         activate_handler(NULL, NULL);
 173         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 174
 175         get_operating_channel_handler(NULL, NULL);
 176
 177         deactivate_handler(NULL, NULL);
 178         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 179
 180         wfd_manager_unload();
 181 }
 182
 183 TEST(wfd_mgr_get, activate_pushbutton_handler_Negative1)
 184 {
 185         activate_pushbutton_handler(NULL, NULL);
 186 }
 187
 188 TEST(wfd_mgr_get, activate_pushbutton_handler_Negative2)
 189 {
 190         wfd_manager_s * manager = NULL;
 191
 192         INIT_WFD_MGR(manager);
 193         manager = wfd_get_manager();
 194
 195         activate_handler(NULL, NULL);
 196         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 197
 198         activate_pushbutton_handler(NULL, NULL);
 199
 200         deactivate_handler(NULL, NULL);
 201         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 202
 203         wfd_manager_unload();
 204 }
 205
 206 TEST(wfd_mgr_get, get_ip_address_handler_Negative1)
 207 {
 208         get_ip_address_handler(NULL, NULL);
 209 }
 210
 211 TEST(wfd_mgr_get, get_ip_address_handler_Negative2)
 212 {
 213         wfd_manager_s * manager = NULL;
 214
 215         INIT_WFD_MGR(manager);
 216         manager = wfd_get_manager();
 217
 218         activate_handler(NULL, NULL);
 219         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 220
 221         get_ip_address_handler(NULL, NULL);
 222
 223         deactivate_handler(NULL, NULL);
 224         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 225
 226         wfd_manager_unload();
 227 }
 228
 229 TEST(wfd_mgr_get, get_interface_name_handler_Negative1)
 230 {
 231         get_interface_name_handler(NULL, NULL);
 232 }
 233
 234 TEST(wfd_mgr_get, get_interface_name_handler_Negative2)
 235 {
 236         wfd_manager_s * manager = NULL;
 237
 238         INIT_WFD_MGR(manager);
 239         manager = wfd_get_manager();
 240
 241         activate_handler(NULL, NULL);
 242         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 243
 244         get_interface_name_handler(NULL, NULL);
 245
 246         deactivate_handler(NULL, NULL);
 247         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 248
 249         wfd_manager_unload();
 250 }
 251
 252
 253 TEST(wfd_mgr_set_get, set_get_device_name_handler_Positive)
 254 {
 255         wfd_manager_s * manager = NULL;
 256         char device_name_orig[WIFI_DIRECT_MAX_DEVICE_NAME_LEN+1] = {0, };
 257         char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN+1] = {0, };
 258         int ret = 0;
 259
 260         INIT_WFD_MGR(manager);
 261         manager = wfd_get_manager();
 262
 263         activate_handler(NULL, NULL);
 264         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 265
 266         ret = wfd_local_get_dev_name(device_name_orig);
 267         ASSERT_EQ(0, ret);
 268
 269         MethodInjector *set_device_name_method = new MethodInjector;
 270         set_device_name_handler(set_device_name_method->SetDeviceName(), NULL);
 271
 272         ret = wfd_local_get_dev_name(device_name);
 273         ASSERT_EQ(0, ret);
 274         ASSERT_STREQ(set_device_name_method->GetDeviceName(), device_name);
 275
 276         get_device_name_handler(NULL, NULL);
 277         ret = wfd_local_set_dev_name(device_name_orig);
 278         ASSERT_EQ(0, ret);
 279
 280         deactivate_handler(NULL, NULL);
 281         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 282
 283         wfd_manager_unload();
 284
 285         delete set_device_name_method;
 286 }
 287
 288 TEST(wfd_mgr_set_get, __set_get_req_wps_mode_handler_Positive)
 289 {
 290         wfd_manager_s * manager = NULL;
 291         int wps_mode_orig = 0;
 292         int wps_mode = 4;
 293         int ret = 0;
 294
 295         INIT_WFD_MGR(manager);
 296         manager = wfd_get_manager();
 297
 298         activate_handler(NULL, NULL);
 299         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 300
 301         ret = wfd_manager_get_req_wps_mode(&wps_mode_orig);
 302         ASSERT_EQ(0, ret);
 303
 304         get_local_wps_mode_handler(NULL, NULL);
 305         get_req_wps_mode_handler(NULL, NULL);
 306
 307         MethodInjector *set_req_wps_method = new MethodInjector;
 308         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
 309         ret = wfd_manager_get_req_wps_mode(&wps_mode);
 310         ASSERT_EQ(4, wps_mode);
 311         ASSERT_EQ(0, ret);
 312
 313         ret = wfd_manager_set_req_wps_mode(wps_mode_orig);
 314         ASSERT_EQ(0, ret);
 315
 316         deactivate_handler(NULL, NULL);
 317         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 318
 319         wfd_manager_unload();
 320         delete set_req_wps_method;
 321 }
 322
 323 TEST(wfd_mgr_set_get, set_get_passphrase_handler_Positive)
 324 {
 325         wfd_manager_s * manager = NULL;
 326
 327         INIT_WFD_MGR(manager);
 328         manager = wfd_get_manager();
 329
 330         activate_handler(NULL, NULL);
 331         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 332
 333         MethodInjector *set_passphrase_method = new MethodInjector;
 334         set_passphrase_handler(set_passphrase_method->SetPassphrase(), NULL);
 335         ASSERT_STREQ(manager->local->passphrase, set_passphrase_method->passphrase);
 336
 337         MethodInjector *group_create_method = new MethodInjector;
 338         create_group_handler(group_create_method->CreateGroup(), NULL);
 339
 340         EventInjector *group_started_event = new EventInjector;
 341         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
 342         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 343
 344         get_passphrase_handler(NULL, NULL);
 345
 346         destroy_group_handler(NULL, NULL);
 347
 348         EventInjector *group_destroy_event = new EventInjector;
 349         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
 350         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 351
 352         deactivate_handler(NULL, NULL);
 353         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 354         wfd_manager_unload();
 355
 356         delete group_create_method;
 357         delete set_passphrase_method;
 358         delete group_started_event;
 359         delete group_destroy_event;
 360 }
 361 TEST(wfd_mgr_set_get, set_passphrase_handler_Negative1)
 362 {
 363         MethodInjector *set_passphrase_method = new MethodInjector;
 364         set_passphrase_handler(set_passphrase_method->SetPassphrase(), NULL);
 365
 366         delete set_passphrase_method;
 367 }
 368
 369 TEST(wfd_mgr_set_get, set_passphrase_handler_Negative2)
 370 {
 371         wfd_manager_s * manager = NULL;
 372
 373         INIT_WFD_MGR(manager);
 374         manager = wfd_get_manager();
 375
 376         activate_handler(NULL, NULL);
 377         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 378
 379         MethodInjector *group_create_method = new MethodInjector;
 380         create_group_handler(group_create_method->CreateGroup(), NULL);
 381
 382         EventInjector *group_started_event = new EventInjector;
 383         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
 384         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 385
 386         MethodInjector *set_passphrase_method = new MethodInjector;
 387         set_passphrase_handler(set_passphrase_method->SetPassphrase(), NULL);
 388         ASSERT_STRNE(manager->local->passphrase, set_passphrase_method->passphrase);
 389
 390         destroy_group_handler(NULL, NULL);
 391
 392         EventInjector *group_destroy_event = new EventInjector;
 393         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
 394         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 395
 396         deactivate_handler(NULL, NULL);
 397         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 398         wfd_manager_unload();
 399
 400         delete set_passphrase_method;
 401         delete group_create_method;
 402         delete group_started_event;
 403         delete group_destroy_event;
 404 }
 405
 406 TEST(wfd_mgr_set_get, set_passphrase_handler_Negative3)
 407 {
 408         wfd_manager_s * manager = NULL;
 409         GVariant *parameters = g_variant_new("(s)", "0");
 410
 411         INIT_WFD_MGR(manager);
 412         manager = wfd_get_manager();
 413
 414         set_passphrase_handler(parameters, NULL);
 415
 416         wfd_manager_unload();
 417         g_variant_unref(parameters);
 418 }
 419
 420 TEST(wfd_mgr_set_get, set_get_go_intent_handler_Positive)
 421 {
 422         wfd_manager_s * manager = NULL;
 423         int go_intent_orig = 0;
 424         int go_intent = 14;
 425         int ret = 0;
 426
 427         INIT_WFD_MGR(manager);
 428         manager = wfd_get_manager();
 429
 430         activate_handler(NULL, NULL);
 431         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 432
 433         ret = wfd_manager_get_go_intent(&go_intent_orig);
 434         ASSERT_EQ(0, ret);
 435
 436         get_go_intent_handler(NULL, NULL);
 437
 438         MethodInjector *set_go_intent_method = new MethodInjector;
 439         set_go_intent_handler(set_go_intent_method->SetGoIntent(go_intent), NULL);
 440
 441         get_go_intent_handler(NULL, NULL);
 442         ret = wfd_manager_get_go_intent(&go_intent);
 443         ASSERT_EQ(14, go_intent);
 444         ASSERT_EQ(0, ret);
 445
 446         ret = wfd_manager_set_go_intent(go_intent_orig);
 447         ASSERT_EQ(0, ret);
 448
 449         deactivate_handler(NULL, NULL);
 450         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 451
 452         wfd_manager_unload();
 453         delete set_go_intent_method;
 454 }
 455
 456 TEST(wfd_mgr_set_get, set_go_intent_handler_Negative)
 457 {
 458         wfd_manager_s * manager = NULL;
 459         int go_intent_orig = 0;
 460         int go_intent = 14;
 461         int ret = 0;
 462
 463         INIT_WFD_MGR(manager);
 464         manager = wfd_get_manager();
 465
 466         activate_handler(NULL, NULL);
 467         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 468
 469         ret = wfd_manager_get_go_intent(&go_intent_orig);
 470         ASSERT_EQ(0, ret);
 471
 472         get_go_intent_handler(NULL, NULL);
 473
 474         MethodInjector *set_go_intent_method = new MethodInjector;
 475         set_go_intent_handler(set_go_intent_method->SetGoIntent(-1), NULL);
 476         ret = wfd_manager_get_go_intent(&go_intent);
 477         ASSERT_EQ(go_intent_orig, go_intent);
 478         ASSERT_EQ(0, ret);
 479
 480         ret = wfd_manager_set_go_intent(go_intent_orig);
 481         ASSERT_EQ(0, ret);
 482
 483         deactivate_handler(NULL, NULL);
 484         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 485
 486         wfd_manager_unload();
 487         delete set_go_intent_method;
 488 }
 489
 490 TEST(wfd_mgr_set_get, set_get_max_client_handler_Positive)
 491 {
 492         wfd_manager_s * manager = NULL;
 493         int max_client_orig = 0;
 494         int max_client = 5;
 495         int ret = 0;
 496
 497         INIT_WFD_MGR(manager);
 498         manager = wfd_get_manager();
 499
 500         activate_handler(NULL, NULL);
 501         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 502
 503         ret = wfd_manager_get_max_station(&max_client_orig);
 504         ASSERT_EQ(0, ret);
 505
 506         MethodInjector *set_max_client_method = new MethodInjector;
 507         set_max_client_handler(set_max_client_method->SetMaxClient(max_client), NULL);
 508
 509         get_max_client_handler(NULL, NULL);
 510         ret = wfd_manager_get_max_station(&max_client);
 511         ASSERT_EQ(5, max_client);
 512         ASSERT_EQ(0, ret);
 513
 514         ret = wfd_manager_set_max_station(max_client_orig);
 515         ASSERT_EQ(0, ret);
 516
 517         deactivate_handler(NULL, NULL);
 518         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 519
 520         wfd_manager_unload();
 521         delete set_max_client_method;
 522 }
 523
 524 TEST(wfd_mgr_set_get, set_max_client_handler_Negative)
 525 {
 526         wfd_manager_s * manager = NULL;
 527         int max_client_orig = 0;
 528         int max_client = 5;
 529         int ret = 0;
 530
 531         INIT_WFD_MGR(manager);
 532         manager = wfd_get_manager();
 533
 534         activate_handler(NULL, NULL);
 535         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 536
 537         ret = wfd_manager_get_max_station(&max_client_orig);
 538         ASSERT_EQ(0, ret);
 539
 540         MethodInjector *set_max_client_method = new MethodInjector;
 541         set_max_client_handler(set_max_client_method->SetMaxClient(-1), NULL);
 542
 543         ret = wfd_manager_get_max_station(&max_client);
 544         ASSERT_EQ(max_client_orig, max_client);
 545         ASSERT_EQ(0, ret);
 546
 547         ret = wfd_manager_set_max_station(max_client_orig);
 548         ASSERT_EQ(0, ret);
 549
 550         deactivate_handler(NULL, NULL);
 551         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 552
 553         wfd_manager_unload();
 554         delete set_max_client_method;
 555 }
 556
 557
 558 TEST(wfd_mgr_set_get, set_autoconnection_mode_handler_Positive)
 559 {
 560         wfd_manager_s * manager = NULL;
 561         int auto_connect_orig = 0;
 562         int auto_connect;
 563         int ret = 0;
 564
 565         INIT_WFD_MGR(manager);
 566         manager = wfd_get_manager();
 567
 568         activate_handler(NULL, NULL);
 569         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 570
 571         ret = wfd_manager_get_autoconnection(&auto_connect_orig);
 572         ASSERT_EQ(0, ret);
 573
 574         MethodInjector *set_auto_connect = new MethodInjector;
 575         set_autoconnection_mode_handler(set_auto_connect->SetAutoConnection(true), NULL);
 576         is_autoconnection_mode_handler(NULL, NULL);
 577         ret = wfd_manager_get_autoconnection(&auto_connect);
 578         ASSERT_EQ(true, auto_connect);
 579
 580         set_autoconnection_mode_handler(set_auto_connect->SetAutoConnection(false), NULL);
 581         ret = wfd_manager_get_autoconnection(&auto_connect);
 582         ASSERT_EQ(false, auto_connect);
 583
 584         deactivate_handler(NULL, NULL);
 585         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 586
 587         wfd_manager_unload();
 588         delete set_auto_connect;
 589 }
 590
 591 TEST(wfd_mgr_set_get, set_get_session_timer_handler_Positive)
 592 {
 593         wfd_manager_s * manager = NULL;
 594         int session_timer_orig = 0;
 595         int session_timer = 5;
 596
 597         INIT_WFD_MGR(manager);
 598         manager = wfd_get_manager();
 599
 600         activate_handler(NULL, NULL);
 601         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 602
 603         session_timer_orig = manager->session_timer;
 604
 605         MethodInjector *set_session_timer_method = new MethodInjector;
 606         set_session_timer_handler(set_session_timer_method->SetSessionTimer(session_timer), NULL);
 607         get_session_timer_handler(NULL, NULL);
 608         session_timer = manager->session_timer;
 609         ASSERT_EQ(5, session_timer);
 610
 611         manager->session_timer = session_timer_orig;
 612
 613         deactivate_handler(NULL, NULL);
 614         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 615
 616         wfd_manager_unload();
 617         delete set_session_timer_method;
 618 }
 619
 620 TEST(wfd_mgr_set_get, set_session_timer_handler_Negative)
 621 {
 622         MethodInjector *set_session_timer_method = new MethodInjector;
 623         set_session_timer_handler(set_session_timer_method->SetSessionTimer(10), NULL);
 624
 625         delete set_session_timer_method;
 626 }
 627
 628 TEST(wfd_mgr_set_get, get_session_timer_handler_Negative)
 629 {
 630         get_session_timer_handler(NULL, NULL);
 631 }
 632
 633 TEST(wfd_mgr_set_get, set_persistent_group_handler_Positive)
 634 {
 635         wfd_manager_s * manager = NULL;
 636
 637         INIT_WFD_MGR(manager);
 638         manager = wfd_get_manager();
 639
 640         activate_handler(NULL, NULL);
 641         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 642
 643         MethodInjector *enable_persistent_group_method = new MethodInjector;
 644         set_persistent_group_handler(enable_persistent_group_method->SetPersistentGroup(true), NULL);
 645         ASSERT_EQ(true, (manager->local->group_flags &
 646                         WFD_GROUP_FLAG_PERSISTENT)
 647                 == WFD_GROUP_FLAG_PERSISTENT);
 648
 649         is_persistent_group_enabled_handler(NULL, NULL);
 650
 651         set_persistent_group_handler(enable_persistent_group_method->SetPersistentGroup(false), NULL);
 652         ASSERT_EQ(false, (manager->local->group_flags &
 653                         WFD_GROUP_FLAG_PERSISTENT)
 654                 == WFD_GROUP_FLAG_PERSISTENT);
 655
 656         deactivate_handler(NULL, NULL);
 657         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 658
 659         wfd_manager_unload();
 660         delete enable_persistent_group_method;
 661 }
 662
 663 TEST(wfd_mgr_set_get, set_persistent_group_handler_Negative)
 664 {
 665         MethodInjector *enable_persistent_group_method = new MethodInjector;
 666         set_persistent_group_handler(enable_persistent_group_method->SetPersistentGroup(true), NULL);
 667
 668         delete enable_persistent_group_method;
 669 }
 670
 671 TEST(wfd_mgr_set_get, get_auto_group_removal_handler_Positive1)
 672 {
 673         wfd_manager_s * manager = NULL;
 674
 675         INIT_WFD_MGR(manager);
 676         manager = wfd_get_manager();
 677
 678         activate_handler(NULL, NULL);
 679         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 680
 681         MethodInjector *set_auto_group_removal_method = new MethodInjector;
 682         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(true), NULL);
 683         ASSERT_EQ(true, manager->auto_group_remove_enable);
 684
 685         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(false), NULL);
 686         ASSERT_EQ(false, manager->auto_group_remove_enable);
 687
 688         MethodInjector *group_create_method = new MethodInjector;
 689         create_group_handler(group_create_method->CreateGroup(), NULL);
 690
 691         EventInjector *group_started_event = new EventInjector;
 692         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
 693         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 694
 695         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(true), NULL);
 696         ASSERT_EQ(true, manager->auto_group_remove_enable);
 697
 698         EventInjector *group_destroy_event = new EventInjector;
 699         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
 700         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 701
 702         deactivate_handler(NULL, NULL);
 703         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 704
 705         wfd_manager_unload();
 706
 707         delete group_create_method;
 708         delete group_started_event;
 709         delete group_destroy_event;
 710         delete set_auto_group_removal_method;
 711 }
 712
 713 TEST(wfd_mgr_set_get, get_auto_group_removal_handler_Positive2)
 714 {
 715         wfd_manager_s * manager = NULL;
 716
 717         INIT_WFD_MGR(manager);
 718         manager = wfd_get_manager();
 719
 720         activate_handler(NULL, NULL);
 721         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 722
 723         MethodInjector *set_auto_group_removal_method = new MethodInjector;
 724         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(true), NULL);
 725         ASSERT_EQ(true, manager->auto_group_remove_enable);
 726
 727         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(false), NULL);
 728         ASSERT_EQ(false, manager->auto_group_remove_enable);
 729
 730         EventInjector *found_event = new EventInjector;
 731         wfd_event_peer_found((wfd_oem_event_s *)found_event->PeerFound());
 732
 733         get_connected_peers_handler(NULL, NULL);
 734
 735         MethodInjector *connect_method = new MethodInjector;
 736         connect_handler(connect_method->Connect(), NULL);
 737
 738         EventInjector *prov_pbc_resp_event = new EventInjector;
 739         wfd_event_prov_disc_resp((wfd_oem_event_s*)prov_pbc_resp_event->ProvPbcResp(false));
 740
 741         EventInjector *go_neg_req_event = new EventInjector;
 742         wfd_event_go_neg_req((wfd_oem_event_s*)go_neg_req_event->GoNegRequestPbc());
 743
 744         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(true), NULL);
 745         ASSERT_EQ(true, manager->auto_group_remove_enable);
 746
 747         deactivate_handler(NULL, NULL);
 748         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 749
 750         wfd_manager_unload();
 751
 752         delete set_auto_group_removal_method;
 753         delete found_event;
 754         delete connect_method;
 755         delete prov_pbc_resp_event;
 756         delete go_neg_req_event;
 757 }
 758
 759 TEST(wfd_mgr_set_get, get_auto_group_removal_handler_Negative1)
 760 {
 761         MethodInjector *set_auto_group_removal_method = new MethodInjector;
 762         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(true), NULL);
 763
 764         delete set_auto_group_removal_method;
 765 }
 766
 767 TEST(wfd_mgr_set_get, get_auto_group_removal_handler_Negative2)
 768 {
 769         wfd_manager_s * manager = NULL;
 770
 771         INIT_WFD_MGR(manager);
 772         manager = wfd_get_manager();
 773
 774         MethodInjector *set_auto_group_removal_method = new MethodInjector;
 775         get_auto_group_removal_handler(set_auto_group_removal_method->SetAutoGroupRemoval(true), NULL);
 776
 777         wfd_manager_unload();
 778         delete set_auto_group_removal_method;
 779 }
 780
 781
 782 TEST(wfd_mgr_discovery, start_discovery_handler_find_Positive1)
 783 {
 784         EventInjector *event = new EventInjector;
 785         wfd_manager_s * manager = NULL;
 786
 787         INIT_WFD_MGR(manager);
 788         manager = wfd_get_manager();
 789
 790         activate_handler(NULL, NULL);
 791         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 792
 793         MethodInjector *find_injector = new MethodInjector;
 794         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 795         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
 796
 797         stop_discovery_handler(NULL, NULL);
 798         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 799
 800         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 801         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
 802
 803         wfd_event_discovery_finished((wfd_oem_event_s*)event->FindStopped());
 804         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 805
 806         deactivate_handler(NULL, NULL);
 807         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 808
 809         wfd_manager_unload();
 810         delete find_injector;
 811         delete event;
 812 }
 813
 814 TEST(wfd_mgr_discovery, start_discovery_handler_find_Positive2)
 815 {
 816         EventInjector *event = new EventInjector;
 817         wfd_manager_s * manager = NULL;
 818
 819         INIT_WFD_MGR(manager);
 820         manager = wfd_get_manager();
 821
 822         activate_handler(NULL, NULL);
 823         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 824
 825         MethodInjector *group_create_method = new MethodInjector;
 826         create_group_handler(group_create_method->CreateGroup(), NULL);
 827
 828         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
 829         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 830
 831         MethodInjector *find_injector = new MethodInjector;
 832         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 833         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 834
 835         stop_discovery_handler(NULL, NULL);
 836         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 837
 838         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 839         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 840
 841         wfd_event_discovery_finished((wfd_oem_event_s*)event->FindStopped());
 842         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 843
 844         destroy_group_handler(NULL, NULL);
 845
 846         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
 847         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 848
 849         deactivate_handler(NULL, NULL);
 850         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 851
 852         wfd_manager_unload();
 853
 854         delete find_injector;
 855         delete group_create_method;
 856         delete event;
 857 }
 858
 859 TEST(wfd_mgr_discovery, start_discovery_handler_Negative1)
 860 {
 861         wfd_manager_s * manager = NULL;
 862         int state = 0;
 863         int ret = 0;
 864
 865         MethodInjector *find_injector = new MethodInjector;
 866         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 867         ret = wfd_state_get(manager, &state);
 868         ASSERT_EQ(-1, ret);
 869
 870         delete find_injector;
 871 }
 872
 873 TEST(wfd_mgr_discovery, start_discovery_handler_find_Negative2)
 874 {
 875         wfd_manager_s * manager = NULL;
 876
 877         INIT_WFD_MGR(manager);
 878         manager = wfd_get_manager();
 879
 880         MethodInjector *find_injector = new MethodInjector;
 881         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 882         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 883
 884         wfd_manager_unload();
 885
 886         delete find_injector;
 887 }
 888
 889 TEST(wfd_mgr_discovery, start_discovery_handler_find_Negative3)
 890 {
 891         wfd_manager_s * manager = NULL;
 892
 893         INIT_WFD_MGR(manager);
 894         manager = wfd_get_manager();
 895
 896         MethodInjector *find_injector = new MethodInjector;
 897         start_discovery_handler(find_injector->StartDiscoveryFind(), NULL);
 898         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 899
 900         wfd_manager_unload();
 901
 902         delete find_injector;
 903 }
 904
 905 TEST(wfd_mgr_discovery, start_discovery_handler_listen_Positive)
 906 {
 907         wfd_manager_s * manager = NULL;
 908
 909         INIT_WFD_MGR(manager);
 910         manager = wfd_get_manager();
 911
 912         activate_handler(NULL, NULL);
 913         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 914
 915         MethodInjector *find_injector = new MethodInjector;
 916         start_discovery_handler(find_injector->StartDiscoveryListen(), NULL);
 917         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
 918
 919         stop_discovery_handler(NULL, NULL);
 920         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 921
 922         deactivate_handler(NULL, NULL);
 923         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 924
 925         wfd_manager_unload();
 926         delete find_injector;
 927 }
 928
 929 TEST(wfd_mgr_discovery, start_discovery_handler_go_Listen)
 930 {
 931         wfd_manager_s * manager = NULL;
 932
 933         INIT_WFD_MGR(manager);
 934         manager = wfd_get_manager();
 935
 936         activate_handler(NULL, NULL);
 937         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 938
 939         MethodInjector *group_create_method = new MethodInjector;
 940         create_group_handler(group_create_method->CreateGroup(), NULL);
 941
 942         EventInjector *group_started_event = new EventInjector;
 943         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
 944         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 945
 946         MethodInjector *find_injector = new MethodInjector;
 947         start_discovery_handler(find_injector->StartDiscoveryListen(), NULL);
 948         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
 949
 950         destroy_group_handler(NULL, NULL);
 951
 952         EventInjector *group_destroy_event = new EventInjector;
 953         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
 954         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 955
 956         deactivate_handler(NULL, NULL);
 957         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 958
 959         wfd_manager_unload();
 960
 961         delete find_injector;
 962         delete group_create_method;
 963         delete group_started_event;
 964         delete group_destroy_event;
 965 }
 966
 967 TEST(wfd_mgr_discovery, start_discovery_handler_get_peer_Positive)
 968 {
 969         wfd_manager_s * manager = NULL;
 970         wfd_oem_event_s *event = NULL;
 971
 972         INIT_WFD_MGR(manager);
 973         manager = wfd_get_manager();
 974
 975         activate_handler(NULL, NULL);
 976         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
 977
 978         EventInjector *found_injector = new EventInjector;
 979         event = (wfd_oem_event_s *)found_injector->PeerFound();
 980         wfd_event_peer_found(event);
 981
 982         get_discovered_peer_handler(NULL, NULL);
 983
 984         EventInjector *lost_injector = new EventInjector;
 985         event = (wfd_oem_event_s *)lost_injector->DeviceLost();
 986         wfd_event_peer_disappeared(event);
 987
 988         deactivate_handler(NULL, NULL);
 989         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
 990
 991         wfd_manager_unload();
 992         delete found_injector;
 993         delete lost_injector;
 994 }
 995
 996 TEST(wfd_mgr_discovery, start_discovery_handler_get_peer_Negative1)
 997 {
 998         get_discovered_peer_handler(NULL, NULL);
 999 }
1000
1001 TEST(wfd_mgr_discovery, start_discovery_handler_get_peer_Negative2)
1002 {
1003         wfd_manager_s * manager = NULL;
1004
1005         INIT_WFD_MGR(manager);
1006         manager = wfd_get_manager();
1007
1008         activate_handler(NULL, NULL);
1009         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1010
1011         get_discovered_peer_handler(NULL, NULL);
1012
1013         deactivate_handler(NULL, NULL);
1014         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1015
1016         wfd_manager_unload();
1017 }
1018
1019 TEST(wfd_mgr_get_peer_info, get_peer_info_handler_Positive)
1020 {
1021         wfd_manager_s * manager = NULL;
1022         EventInjector *event = new EventInjector;
1023
1024         INIT_WFD_MGR(manager);
1025         manager = wfd_get_manager();
1026
1027         activate_handler(NULL, NULL);
1028         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1029
1030         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
1031
1032         MethodInjector *peer_dev_addr = new MethodInjector;
1033         get_peer_info_handler(peer_dev_addr->GetPeerAddr(), NULL);
1034         get_peer_rssi_handler(peer_dev_addr->GetPeerAddr(), NULL);
1035         display_get_peer_type_handler(peer_dev_addr->GetPeerAddr(), NULL);
1036         display_get_peer_type_handler(peer_dev_addr->GetPeerAddr(), NULL);
1037         display_get_peer_hdcp_handler(peer_dev_addr->GetPeerAddr(), NULL);
1038         display_get_peer_port_handler(peer_dev_addr->GetPeerAddr(), NULL);
1039         display_get_peer_throughput_handler(peer_dev_addr->GetPeerAddr(), NULL);
1040
1041         wfd_event_peer_disappeared((wfd_oem_event_s *)event->DeviceLost());
1042
1043         deactivate_handler(NULL, NULL);
1044         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1045
1046         wfd_manager_unload();
1047         delete event;
1048         delete peer_dev_addr;
1049 }
1050
1051 TEST(wfd_mgr_get_peer_info, get_peer_info_handler_Negative1)
1052 {
1053         MethodInjector *peer_dev_addr = new MethodInjector;
1054         get_peer_info_handler(peer_dev_addr->GetPeerAddr(), NULL);
1055         delete peer_dev_addr;
1056 }
1057
1058 TEST(wfd_mgr_get_peer_info, get_peer_info_handler_Negative2)
1059 {
1060         wfd_manager_s * manager = NULL;
1061
1062         INIT_WFD_MGR(manager);
1063         manager = wfd_get_manager();
1064
1065         activate_handler(NULL, NULL);
1066         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1067
1068         MethodInjector *peer_dev_addr = new MethodInjector;
1069         get_peer_info_handler(peer_dev_addr->GetPeerAddr(), NULL);
1070
1071         deactivate_handler(NULL, NULL);
1072         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1073
1074         wfd_manager_unload();
1075         delete peer_dev_addr;
1076 }
1077
1078 TEST(wfd_mgr_get_peer_info, get_peer_rssi_handler_Negative1)
1079 {
1080         MethodInjector *peer_dev_addr = new MethodInjector;
1081         get_peer_rssi_handler(peer_dev_addr->GetPeerAddr(), NULL);
1082         delete peer_dev_addr;
1083 }
1084
1085 TEST(wfd_mgr_get_peer_info, get_peer_rssi_handler_Negative2)
1086 {
1087         wfd_manager_s * manager = NULL;
1088
1089         INIT_WFD_MGR(manager);
1090         manager = wfd_get_manager();
1091
1092         MethodInjector *peer_dev_addr = new MethodInjector;
1093         get_peer_rssi_handler(peer_dev_addr->GetPeerAddr(), NULL);
1094
1095         wfd_manager_unload();
1096         delete peer_dev_addr;
1097 }
1098
1099 TEST(wfd_mgr_get_peer_info, get_peer_rssi_handler_Negative3)
1100 {
1101         wfd_manager_s * manager = NULL;
1102
1103         INIT_WFD_MGR(manager);
1104         manager = wfd_get_manager();
1105
1106         activate_handler(NULL, NULL);
1107         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1108
1109         MethodInjector *peer_dev_addr = new MethodInjector;
1110         get_peer_rssi_handler(peer_dev_addr->GetPeerAddr(), NULL);
1111
1112         deactivate_handler(NULL, NULL);
1113         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1114
1115         wfd_manager_unload();
1116         delete peer_dev_addr;
1117 }
1118
1119 TEST(wfd_mgr_get_peer_info, display_get_peer_type_handler_Negative1)
1120 {
1121         MethodInjector *peer_dev_addr = new MethodInjector;
1122         display_get_peer_type_handler(peer_dev_addr->GetPeerAddr(), NULL);
1123         delete peer_dev_addr;
1124 }
1125
1126 TEST(wfd_mgr_get_peer_info, display_get_peer_type_handler_Negative2)
1127 {
1128         wfd_manager_s * manager = NULL;
1129
1130         INIT_WFD_MGR(manager);
1131         manager = wfd_get_manager();
1132         manager->is_wifi_display_supported = false;
1133
1134         MethodInjector *peer_dev_addr = new MethodInjector;
1135         display_get_peer_type_handler(peer_dev_addr->GetPeerAddr(), NULL);
1136
1137         wfd_manager_unload();
1138         delete peer_dev_addr;
1139 }
1140
1141 TEST(wfd_mgr_get_peer_info, display_get_peer_type_handler_Negative3)
1142 {
1143         wfd_manager_s * manager = NULL;
1144
1145         INIT_WFD_MGR(manager);
1146         manager = wfd_get_manager();
1147         manager->is_wifi_display_supported = true;
1148
1149         MethodInjector *peer_dev_addr = new MethodInjector;
1150         display_get_peer_type_handler(peer_dev_addr->GetPeerAddr(), NULL);
1151
1152         wfd_manager_unload();
1153         delete peer_dev_addr;
1154 }
1155
1156 TEST(wfd_mgr_get_peer_info, display_get_peer_type_handler_Negative4)
1157 {
1158         wfd_manager_s * manager = NULL;
1159
1160         INIT_WFD_MGR(manager);
1161         manager = wfd_get_manager();
1162         manager->is_wifi_display_supported = true;
1163
1164         activate_handler(NULL, NULL);
1165         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1166
1167         MethodInjector *peer_dev_addr = new MethodInjector;
1168         display_get_peer_type_handler(peer_dev_addr->GetPeerAddr(), NULL);
1169
1170         deactivate_handler(NULL, NULL);
1171         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1172
1173         wfd_manager_unload();
1174         delete peer_dev_addr;
1175 }
1176
1177 TEST(wfd_mgr_get_peer_info, display_get_peer_avail_handler_Negative1)
1178 {
1179         MethodInjector *peer_dev_addr = new MethodInjector;
1180         display_get_peer_avail_handler(peer_dev_addr->GetPeerAddr(), NULL);
1181         delete peer_dev_addr;
1182 }
1183
1184 TEST(wfd_mgr_get_peer_info, display_get_peer_avail_handler_Negative2)
1185 {
1186         wfd_manager_s * manager = NULL;
1187
1188         INIT_WFD_MGR(manager);
1189         manager = wfd_get_manager();
1190         manager->is_wifi_display_supported = false;
1191
1192         MethodInjector *peer_dev_addr = new MethodInjector;
1193         display_get_peer_avail_handler(peer_dev_addr->GetPeerAddr(), NULL);
1194
1195         wfd_manager_unload();
1196         delete peer_dev_addr;
1197 }
1198
1199 TEST(wfd_mgr_get_peer_info, display_get_peer_avail_handler_Negative3)
1200 {
1201         wfd_manager_s * manager = NULL;
1202
1203         INIT_WFD_MGR(manager);
1204         manager = wfd_get_manager();
1205         manager->is_wifi_display_supported = true;
1206
1207         MethodInjector *peer_dev_addr = new MethodInjector;
1208         display_get_peer_avail_handler(peer_dev_addr->GetPeerAddr(), NULL);
1209
1210         wfd_manager_unload();
1211         delete peer_dev_addr;
1212 }
1213
1214 TEST(wfd_mgr_get_peer_info, display_get_peer_avail_handler_Negative4)
1215 {
1216         wfd_manager_s * manager = NULL;
1217
1218         INIT_WFD_MGR(manager);
1219         manager = wfd_get_manager();
1220         manager->is_wifi_display_supported = true;
1221
1222         activate_handler(NULL, NULL);
1223         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1224
1225         MethodInjector *peer_dev_addr = new MethodInjector;
1226         display_get_peer_avail_handler(peer_dev_addr->GetPeerAddr(), NULL);
1227
1228         deactivate_handler(NULL, NULL);
1229         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1230
1231         wfd_manager_unload();
1232         delete peer_dev_addr;
1233 }
1234
1235 TEST(wfd_mgr_get_peer_info, display_get_peer_hdcp_handler_Negative1)
1236 {
1237         MethodInjector *peer_dev_addr = new MethodInjector;
1238         display_get_peer_hdcp_handler(peer_dev_addr->GetPeerAddr(), NULL);
1239         delete peer_dev_addr;
1240 }
1241
1242 TEST(wfd_mgr_get_peer_info, display_get_peer_hdcp_handler_Negative2)
1243 {
1244         wfd_manager_s * manager = NULL;
1245
1246         INIT_WFD_MGR(manager);
1247         manager = wfd_get_manager();
1248         manager->is_wifi_display_supported = false;
1249
1250         MethodInjector *peer_dev_addr = new MethodInjector;
1251         display_get_peer_hdcp_handler(peer_dev_addr->GetPeerAddr(), NULL);
1252
1253         wfd_manager_unload();
1254         delete peer_dev_addr;
1255 }
1256
1257 TEST(wfd_mgr_get_peer_info, display_get_peer_hdcp_handler_Negative3)
1258 {
1259         wfd_manager_s * manager = NULL;
1260
1261         INIT_WFD_MGR(manager);
1262         manager = wfd_get_manager();
1263         manager->is_wifi_display_supported = true;
1264
1265         MethodInjector *peer_dev_addr = new MethodInjector;
1266         display_get_peer_hdcp_handler(peer_dev_addr->GetPeerAddr(), NULL);
1267
1268         wfd_manager_unload();
1269         delete peer_dev_addr;
1270 }
1271
1272 TEST(wfd_mgr_get_peer_info, display_get_peer_hdcp_handler_Negative4)
1273 {
1274         wfd_manager_s * manager = NULL;
1275
1276         INIT_WFD_MGR(manager);
1277         manager = wfd_get_manager();
1278         manager->is_wifi_display_supported = true;
1279
1280         activate_handler(NULL, NULL);
1281         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1282
1283         MethodInjector *peer_dev_addr = new MethodInjector;
1284         display_get_peer_hdcp_handler(peer_dev_addr->GetPeerAddr(), NULL);
1285
1286         deactivate_handler(NULL, NULL);
1287         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1288
1289         wfd_manager_unload();
1290         delete peer_dev_addr;
1291 }
1292
1293 TEST(wfd_mgr_get_peer_info, display_get_peer_port_handler_Negative1)
1294 {
1295         MethodInjector *peer_dev_addr = new MethodInjector;
1296         display_get_peer_port_handler(peer_dev_addr->GetPeerAddr(), NULL);
1297         delete peer_dev_addr;
1298 }
1299
1300 TEST(wfd_mgr_get_peer_info, display_get_peer_port_handler_Negative2)
1301 {
1302         wfd_manager_s * manager = NULL;
1303
1304         INIT_WFD_MGR(manager);
1305         manager = wfd_get_manager();
1306         manager->is_wifi_display_supported = false;
1307
1308         MethodInjector *peer_dev_addr = new MethodInjector;
1309         display_get_peer_port_handler(peer_dev_addr->GetPeerAddr(), NULL);
1310
1311         wfd_manager_unload();
1312         delete peer_dev_addr;
1313 }
1314
1315 TEST(wfd_mgr_get_peer_info, display_get_peer_port_handler_Negative3)
1316 {
1317         wfd_manager_s * manager = NULL;
1318
1319         INIT_WFD_MGR(manager);
1320         manager = wfd_get_manager();
1321         manager->is_wifi_display_supported = true;
1322
1323         MethodInjector *peer_dev_addr = new MethodInjector;
1324         display_get_peer_port_handler(peer_dev_addr->GetPeerAddr(), NULL);
1325
1326         wfd_manager_unload();
1327         delete peer_dev_addr;
1328 }
1329
1330 TEST(wfd_mgr_get_peer_info, display_get_peer_port_handler_Negative4)
1331 {
1332         wfd_manager_s * manager = NULL;
1333
1334         INIT_WFD_MGR(manager);
1335         manager = wfd_get_manager();
1336         manager->is_wifi_display_supported = true;
1337
1338         activate_handler(NULL, NULL);
1339         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1340
1341         MethodInjector *peer_dev_addr = new MethodInjector;
1342         display_get_peer_port_handler(peer_dev_addr->GetPeerAddr(), NULL);
1343
1344         deactivate_handler(NULL, NULL);
1345         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1346
1347         wfd_manager_unload();
1348         delete peer_dev_addr;
1349 }
1350
1351 TEST(wfd_mgr_get_peer_info, display_get_peer_throughput_handler_Negative1)
1352 {
1353         MethodInjector *peer_dev_addr = new MethodInjector;
1354         display_get_peer_throughput_handler(peer_dev_addr->GetPeerAddr(), NULL);
1355         delete peer_dev_addr;
1356 }
1357
1358 TEST(wfd_mgr_get_peer_info, display_get_peer_throughput_handler_Negative2)
1359 {
1360         wfd_manager_s * manager = NULL;
1361
1362         INIT_WFD_MGR(manager);
1363         manager = wfd_get_manager();
1364         manager->is_wifi_display_supported = false;
1365
1366         MethodInjector *peer_dev_addr = new MethodInjector;
1367         display_get_peer_throughput_handler(peer_dev_addr->GetPeerAddr(), NULL);
1368
1369         wfd_manager_unload();
1370         delete peer_dev_addr;
1371 }
1372
1373 TEST(wfd_mgr_get_peer_info, display_get_peer_throughput_handler_Negative3)
1374 {
1375         wfd_manager_s * manager = NULL;
1376
1377         INIT_WFD_MGR(manager);
1378         manager = wfd_get_manager();
1379         manager->is_wifi_display_supported = true;
1380
1381         MethodInjector *peer_dev_addr = new MethodInjector;
1382         display_get_peer_throughput_handler(peer_dev_addr->GetPeerAddr(), NULL);
1383
1384         wfd_manager_unload();
1385         delete peer_dev_addr;
1386 }
1387
1388 TEST(wfd_mgr_get_peer_info, display_get_peer_throughput_handler_Negative4)
1389 {
1390         wfd_manager_s * manager = NULL;
1391
1392         INIT_WFD_MGR(manager);
1393         manager = wfd_get_manager();
1394         manager->is_wifi_display_supported = true;
1395
1396         activate_handler(NULL, NULL);
1397         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1398
1399         MethodInjector *peer_dev_addr = new MethodInjector;
1400         display_get_peer_throughput_handler(peer_dev_addr->GetPeerAddr(), NULL);
1401
1402         deactivate_handler(NULL, NULL);
1403         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1404
1405         wfd_manager_unload();
1406         delete peer_dev_addr;
1407 }
1408
1409 TEST(wfd_mgr_gruop, create_group_handler_Positive)
1410 {
1411         wfd_manager_s * manager = NULL;
1412
1413         INIT_WFD_MGR(manager);
1414         manager = wfd_get_manager();
1415
1416         activate_handler(NULL, NULL);
1417         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1418
1419         MethodInjector *group_create_method = new MethodInjector;
1420         create_group_handler(group_create_method->CreateGroup(), NULL);
1421
1422         EventInjector *group_started_event = new EventInjector;
1423         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
1424         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1425
1426         destroy_group_handler(NULL, NULL);
1427
1428         EventInjector *group_destroy_event = new EventInjector;
1429         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
1430         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1431
1432         deactivate_handler(NULL, NULL);
1433         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1434
1435         wfd_manager_unload();
1436
1437         delete group_create_method;
1438         delete group_started_event;
1439         delete group_destroy_event;
1440 }
1441
1442 TEST(wfd_mgr_gruop, create_group_handler_Negative1)
1443 {
1444         wfd_manager_s * manager = NULL;
1445         int state = 0;
1446         int ret = 0;
1447         manager = wfd_get_manager();
1448
1449         MethodInjector *group_create_method = new MethodInjector;
1450         create_group_handler(group_create_method->CreateGroup(), NULL);
1451
1452         ret = wfd_state_get(manager, &state);
1453         ASSERT_EQ(-1, ret);
1454
1455         delete group_create_method;
1456 }
1457
1458 TEST(wfd_mgr_gruop, create_group_handler_Negative2)
1459 {
1460         wfd_manager_s * manager = NULL;
1461
1462         INIT_WFD_MGR(manager);
1463         manager = wfd_get_manager();
1464
1465         MethodInjector *group_create_method = new MethodInjector;
1466         create_group_handler(group_create_method->CreateGroup(), NULL);
1467         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1468
1469         wfd_manager_unload();
1470         delete group_create_method;
1471 }
1472
1473 TEST(wfd_mgr_gruop, create_group_handler_Negative3)
1474 {
1475         wfd_manager_s * manager = NULL;
1476
1477         INIT_WFD_MGR(manager);
1478         manager = wfd_get_manager();
1479
1480         activate_handler(NULL, NULL);
1481         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1482
1483         MethodInjector *group_create_method = new MethodInjector;
1484         create_group_handler(group_create_method->CreateGroup(), NULL);
1485
1486         EventInjector *group_started_event = new EventInjector;
1487         wfd_event_group_created((wfd_oem_event_s*)group_started_event->GroupStartedGO());
1488         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1489
1490         create_group_handler(group_create_method->CreateGroup(), NULL);
1491
1492         destroy_group_handler(NULL, NULL);
1493
1494         EventInjector *group_destroy_event = new EventInjector;
1495         wfd_event_group_destroyed((wfd_oem_event_s*)group_destroy_event->GroupFinished());
1496         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1497
1498         deactivate_handler(NULL, NULL);
1499         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1500
1501         wfd_manager_unload();
1502
1503         delete group_create_method;
1504         delete group_started_event;
1505         delete group_destroy_event;
1506 }
1507
1508 TEST(wfd_mgr_gruop, destroy_group_handler_Negative1)
1509 {
1510         wfd_manager_s * manager = NULL;
1511         int state = 0;
1512         int ret = 0;
1513
1514         manager = wfd_get_manager();
1515
1516         destroy_group_handler(NULL, NULL);
1517
1518         ret = wfd_state_get(manager, &state);
1519         ASSERT_EQ(-1, ret);
1520 }
1521
1522 TEST(wfd_mgr_gruop, destroy_group_handler_Negative2)
1523 {
1524         wfd_manager_s * manager = NULL;
1525
1526         INIT_WFD_MGR(manager);
1527         manager = wfd_get_manager();
1528
1529         activate_handler(NULL, NULL);
1530         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1531
1532         destroy_group_handler(NULL, NULL);
1533         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1534
1535         deactivate_handler(NULL, NULL);
1536         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1537
1538         wfd_manager_unload();
1539 }
1540
1541 TEST(wfd_mgr_vsie, add_get_remove_vsie_handler_Positive)
1542 {
1543         wfd_manager_s * manager = NULL;
1544
1545         INIT_WFD_MGR(manager);
1546         manager = wfd_get_manager();
1547
1548         activate_handler(NULL, NULL);
1549         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1550
1551         MethodInjector *add_vsie_method = new MethodInjector;
1552         add_vsie_handler(add_vsie_method->AddVsie(), NULL);
1553
1554         MethodInjector *get_vsie_method = new MethodInjector;
1555         get_vsie_handler(get_vsie_method->GetVsie(), NULL);
1556
1557         MethodInjector *remove_vsie_method = new MethodInjector;
1558         remove_vsie_handler(remove_vsie_method->RemoveVsie(), NULL);
1559
1560         deactivate_handler(NULL, NULL);
1561         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1562
1563         wfd_manager_unload();
1564
1565         delete add_vsie_method;
1566         delete get_vsie_method;
1567         delete remove_vsie_method;
1568 }
1569
1570 TEST(wfd_mgr_vsie, add_vsie_handler_Negative1)
1571 {
1572         MethodInjector *add_vsie_method = new MethodInjector;
1573         add_vsie_handler(add_vsie_method->AddVsie(), NULL);
1574         delete add_vsie_method;
1575 }
1576
1577 TEST(wfd_mgr_vsie, add_vsie_handler_Negative2)
1578 {
1579         wfd_manager_s * manager = NULL;
1580
1581         INIT_WFD_MGR(manager);
1582         manager = wfd_get_manager();
1583
1584         MethodInjector *add_vsie_method = new MethodInjector;
1585         add_vsie_handler(add_vsie_method->AddVsie(), NULL);
1586
1587         wfd_manager_unload();
1588
1589         delete add_vsie_method;
1590 }
1591
1592 TEST(wfd_mgr_vsie, get_vsie_handler_Negative1)
1593 {
1594         MethodInjector *get_vsie_method = new MethodInjector;
1595         get_vsie_handler(get_vsie_method->GetVsie(), NULL);
1596         delete get_vsie_method;
1597 }
1598
1599 TEST(wfd_mgr_vsie, get_vsie_handler_Negative2)
1600 {
1601         wfd_manager_s * manager = NULL;
1602
1603         INIT_WFD_MGR(manager);
1604         manager = wfd_get_manager();
1605
1606         MethodInjector *get_vsie_method = new MethodInjector;
1607         get_vsie_handler(get_vsie_method->GetVsie(), NULL);
1608
1609         wfd_manager_unload();
1610
1611         delete get_vsie_method;
1612 }
1613
1614 TEST(wfd_mgr_vsie, remove_vsie_handler_Negative1)
1615 {
1616         MethodInjector *remove_vsie_method = new MethodInjector;
1617         remove_vsie_handler(remove_vsie_method->RemoveVsie(), NULL);
1618         delete remove_vsie_method;
1619 }
1620
1621 TEST(wfd_mgr_vsie, remove_vsie_handler_Negative2)
1622 {
1623         wfd_manager_s * manager = NULL;
1624
1625         INIT_WFD_MGR(manager);
1626         manager = wfd_get_manager();
1627
1628         MethodInjector *remove_vsie_method = new MethodInjector;
1629         remove_vsie_handler(remove_vsie_method->RemoveVsie(), NULL);
1630
1631         wfd_manager_unload();
1632
1633         delete remove_vsie_method;
1634 }
1635
1636
1637 TEST(wfd_mgr_display, display_set_handler_Positive)
1638 {
1639         wfd_manager_s * manager = NULL;
1640         wfd_device_s *device = NULL;
1641
1642         INIT_WFD_MGR(manager);
1643         manager = wfd_get_manager();
1644
1645         activate_handler(NULL, NULL);
1646         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1647
1648         display_init_handler(NULL, NULL);
1649         device = manager->local;
1650         ASSERT_EQ(device->display.type, WIFI_DISPLAY_DEFAULT_TYPE);
1651         ASSERT_EQ(device->display.port, WIFI_DISPLAY_DEFAULT_PORT);
1652         ASSERT_EQ(device->display.availability, WIFI_DISPLAY_DEFAULT_AVAIL);
1653         ASSERT_EQ(device->display.hdcp_support, WIFI_DISPLAY_DEFAULT_HDCP);
1654
1655         MethodInjector *set_display_method = new MethodInjector;
1656         display_set_config_handler(set_display_method->SetDisplay(), NULL);
1657         ASSERT_EQ(device->display.type, set_display_method->display_type);
1658         ASSERT_EQ(device->display.port, set_display_method->display_port);
1659         ASSERT_EQ(device->display.hdcp_support, set_display_method->display_hdcp);
1660
1661         MethodInjector *set_display_avail_method = new MethodInjector;
1662         display_set_avail_handler(set_display_avail_method->SetDisplayAvail(), NULL);
1663         ASSERT_EQ(device->display.availability, set_display_avail_method->display_avail);
1664
1665         display_deinit_handler(NULL, NULL);
1666         ASSERT_EQ(device->display.type, 0);
1667         ASSERT_EQ(device->display.port, 0);
1668         ASSERT_EQ(device->display.availability, 0);
1669         ASSERT_EQ(device->display.hdcp_support, 0);
1670
1671         deactivate_handler(NULL, NULL);
1672         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1673
1674         wfd_manager_unload();
1675
1676         delete set_display_method;
1677         delete set_display_avail_method;
1678 }
1679
1680 TEST(wfd_mgr_display, display_init_handler_Negative1)
1681 {
1682         display_init_handler(NULL, NULL);
1683 }
1684
1685 TEST(wfd_mgr_display, display_init_handler_Negative2)
1686 {
1687         wfd_manager_s * manager = NULL;
1688
1689         INIT_WFD_MGR(manager);
1690         manager = wfd_get_manager();
1691
1692         display_init_handler(NULL, NULL);
1693
1694         wfd_manager_unload();
1695 }
1696
1697 TEST(wfd_mgr_display, display_init_handler_Negative3)
1698 {
1699         wfd_manager_s * manager = NULL;
1700
1701         INIT_WFD_MGR(manager);
1702         manager = wfd_get_manager();
1703         manager->is_wifi_display_supported = false;
1704
1705         display_init_handler(NULL, NULL);
1706
1707         wfd_manager_unload();
1708 }
1709
1710 TEST(wfd_mgr_display, display_init_handler_Negative4)
1711 {
1712         wfd_manager_s * manager = NULL;
1713
1714         INIT_WFD_MGR(manager);
1715         manager = wfd_get_manager();
1716         manager->is_wifi_display_supported = true;
1717
1718         display_init_handler(NULL, NULL);
1719
1720         wfd_manager_unload();
1721 }
1722
1723 TEST(wfd_mgr_display, display_deinit_handler_Negative1)
1724 {
1725         display_deinit_handler(NULL, NULL);
1726 }
1727
1728 TEST(wfd_mgr_display, display_deinit_handler_Negative2)
1729 {
1730         wfd_manager_s * manager = NULL;
1731
1732         INIT_WFD_MGR(manager);
1733         manager = wfd_get_manager();
1734
1735         display_deinit_handler(NULL, NULL);
1736
1737         wfd_manager_unload();
1738 }
1739
1740 TEST(wfd_mgr_display, display_deinit_handler_Negative3)
1741 {
1742         wfd_manager_s * manager = NULL;
1743
1744         INIT_WFD_MGR(manager);
1745         manager = wfd_get_manager();
1746         manager->is_wifi_display_supported = false;
1747
1748         display_deinit_handler(NULL, NULL);
1749
1750         wfd_manager_unload();
1751 }
1752
1753 TEST(wfd_mgr_display, display_deinit_handler_Negative4)
1754 {
1755         wfd_manager_s * manager = NULL;
1756
1757         INIT_WFD_MGR(manager);
1758         manager = wfd_get_manager();
1759         manager->is_wifi_display_supported = true;
1760
1761         display_deinit_handler(NULL, NULL);
1762
1763         wfd_manager_unload();
1764 }
1765
1766 TEST(wfd_mgr_display, display_set_config_handler_Negative1)
1767 {
1768         display_set_config_handler(NULL, NULL);
1769 }
1770
1771 TEST(wfd_mgr_display, display_set_config_handler_Negative2)
1772 {
1773         wfd_manager_s * manager = NULL;
1774
1775         INIT_WFD_MGR(manager);
1776         manager = wfd_get_manager();
1777
1778         display_set_config_handler(NULL, NULL);
1779
1780         wfd_manager_unload();
1781 }
1782
1783 TEST(wfd_mgr_display, display_set_config_handler_Negative3)
1784 {
1785         wfd_manager_s * manager = NULL;
1786
1787         INIT_WFD_MGR(manager);
1788         manager = wfd_get_manager();
1789         manager->is_wifi_display_supported = false;
1790
1791         display_set_config_handler(NULL, NULL);
1792
1793         wfd_manager_unload();
1794 }
1795
1796 TEST(wfd_mgr_display, display_set_config_handler_Negative4)
1797 {
1798         wfd_manager_s * manager = NULL;
1799
1800         INIT_WFD_MGR(manager);
1801         manager = wfd_get_manager();
1802         manager->is_wifi_display_supported = true;
1803
1804         display_set_config_handler(NULL, NULL);
1805
1806         wfd_manager_unload();
1807 }
1808
1809 TEST(wfd_mgr_display, display_set_avail_handler_Negative1)
1810 {
1811         display_set_avail_handler(NULL, NULL);
1812 }
1813
1814 TEST(wfd_mgr_display, display_set_avail_handler_Negative2)
1815 {
1816         wfd_manager_s * manager = NULL;
1817
1818         INIT_WFD_MGR(manager);
1819         manager = wfd_get_manager();
1820
1821         display_set_avail_handler(NULL, NULL);
1822
1823         wfd_manager_unload();
1824 }
1825
1826 TEST(wfd_mgr_display, display_set_avail_handler_Negative3)
1827 {
1828         wfd_manager_s * manager = NULL;
1829
1830         INIT_WFD_MGR(manager);
1831         manager = wfd_get_manager();
1832         manager->is_wifi_display_supported = false;
1833
1834         display_set_avail_handler(NULL, NULL);
1835
1836         wfd_manager_unload();
1837 }
1838
1839 TEST(wfd_mgr_display, display_set_avail_handler_Negative4)
1840 {
1841         wfd_manager_s * manager = NULL;
1842
1843         INIT_WFD_MGR(manager);
1844         manager = wfd_get_manager();
1845         manager->is_wifi_display_supported = true;
1846
1847         display_set_avail_handler(NULL, NULL);
1848
1849         wfd_manager_unload();
1850 }
1851
1852
1853 TEST(wfd_mgr_connection, connection_Positive1)
1854 {
1855         EventInjector *event = new EventInjector;
1856         wfd_manager_s * manager = NULL;
1857
1858         INIT_WFD_MGR(manager);
1859         manager = wfd_get_manager();
1860
1861         activate_handler(NULL, NULL);
1862         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1863
1864         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
1865
1866         get_connected_peers_handler(NULL, NULL);
1867
1868         MethodInjector *connect_method = new MethodInjector;
1869         connect_handler(connect_method->Connect(), NULL);
1870         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
1871
1872         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
1873         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
1874         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
1875
1876         get_connecting_peer_handler(NULL, NULL);
1877
1878         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
1879         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
1880         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1881
1882         get_connected_peers_handler(NULL, NULL);
1883
1884         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
1885         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1886
1887         deactivate_handler(NULL, NULL);
1888         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1889
1890         wfd_manager_unload();
1891
1892         delete event;
1893         delete connect_method;
1894 }
1895
1896 TEST(wfd_mgr_connection, connection_Positive2)
1897 {
1898         EventInjector *event = new EventInjector;
1899         wfd_manager_s * manager = NULL;
1900
1901         INIT_WFD_MGR(manager);
1902         manager = wfd_get_manager();
1903
1904         activate_handler(NULL, NULL);
1905         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1906
1907         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
1908
1909         MethodInjector *connect_method = new MethodInjector;
1910         connect_handler(connect_method->Connect(), NULL);
1911         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
1912
1913         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
1914         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
1915         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
1916         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
1917         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoinedwithIP());
1918         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1919
1920         get_connected_peers_handler(NULL, NULL);
1921
1922         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
1923         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1924
1925         deactivate_handler(NULL, NULL);
1926         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1927
1928         wfd_manager_unload();
1929
1930         delete event;
1931         delete connect_method;
1932 }
1933
1934 TEST(wfd_mgr_connection, connection_Positive3)
1935 {
1936         EventInjector *event = new EventInjector;
1937         wfd_manager_s * manager = NULL;
1938
1939         INIT_WFD_MGR(manager);
1940         manager = wfd_get_manager();
1941
1942         activate_handler(NULL, NULL);
1943         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1944
1945         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
1946
1947         MethodInjector *connect_method = new MethodInjector;
1948         connect_handler(connect_method->Connect(), NULL);
1949         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
1950
1951         wfd_event_prov_disc_resp((wfd_oem_event_s *)event->ProvPbcResp(false));
1952         wfd_event_go_neg_req((wfd_oem_event_s *)event->GoNegRequestPbc());
1953         wfd_event_go_neg_done((wfd_oem_event_s *)event->GoNegSuccessGo());
1954
1955         wfd_event_peer_disappeared((wfd_oem_event_s *)event->DeviceLost());
1956
1957         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
1958         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoinedwithIP());
1959         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
1960
1961         get_connected_peers_handler(NULL, NULL);
1962
1963         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
1964         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1965
1966         deactivate_handler(NULL, NULL);
1967         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1968
1969         wfd_manager_unload();
1970
1971         delete event;
1972         delete connect_method;
1973 }
1974
1975
1976 TEST(wfd_mgr_connection, connection_Positive4)
1977 {
1978         wfd_manager_s * manager = NULL;
1979         EventInjector *event = new EventInjector;
1980
1981         INIT_WFD_MGR(manager);
1982         manager = wfd_get_manager();
1983
1984         activate_handler(NULL, NULL);
1985         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1986
1987         wfd_event_invitation_accepted((wfd_oem_event_s*)event->InvitationAccepted());
1988         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
1989
1990         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGCPersistent());
1991         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
1992
1993         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
1994         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
1995
1996         deactivate_handler(NULL, NULL);
1997         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
1998
1999         wfd_manager_unload();
2000
2001         delete event;
2002 }
2003
2004 TEST(wfd_mgr_connection, get_connected_peers_handler_Negative1)
2005 {
2006         get_connected_peers_handler(NULL, NULL);
2007 }
2008
2009 TEST(wfd_mgr_connection, get_connected_peers_handler_Negative2)
2010 {
2011         wfd_manager_s * manager = NULL;
2012
2013         INIT_WFD_MGR(manager);
2014         manager = wfd_get_manager();
2015
2016         activate_handler(NULL, NULL);
2017         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2018
2019         get_connected_peers_handler(NULL, NULL);
2020
2021         deactivate_handler(NULL, NULL);
2022         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2023
2024         wfd_manager_unload();
2025 }
2026
2027 TEST(wfd_mgr_connection, get_connected_peers_handler_Negative3)
2028 {
2029         EventInjector *event = new EventInjector;
2030         wfd_manager_s * manager = NULL;
2031
2032         INIT_WFD_MGR(manager);
2033         manager = wfd_get_manager();
2034
2035         activate_handler(NULL, NULL);
2036         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2037
2038         MethodInjector *group_create_method = new MethodInjector;
2039         create_group_handler(group_create_method->CreateGroup(), NULL);
2040
2041         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2042         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2043
2044         get_connected_peers_handler(NULL, NULL);
2045
2046         destroy_group_handler(NULL, NULL);
2047
2048         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2049         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2050
2051         deactivate_handler(NULL, NULL);
2052         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2053
2054         wfd_manager_unload();
2055
2056         delete group_create_method;
2057         delete event;
2058 }
2059
2060 TEST(wfd_mgr_connection, connect_handler_Negative1)
2061 {
2062         MethodInjector *connect_method = new MethodInjector;
2063         connect_handler(connect_method->Connect(), NULL);
2064
2065         delete connect_method;
2066 }
2067
2068 TEST(wfd_mgr_connection, connect_handler_Negative2)
2069 {
2070         wfd_manager_s * manager = NULL;
2071
2072         INIT_WFD_MGR(manager);
2073         manager = wfd_get_manager();
2074
2075         MethodInjector *connect_method = new MethodInjector;
2076         connect_handler(connect_method->Connect(), NULL);
2077
2078         wfd_manager_unload();
2079
2080         delete connect_method;
2081 }
2082
2083 TEST(wfd_mgr_connection, connect_handler_Negative3)
2084 {
2085         EventInjector *event = new EventInjector;
2086         wfd_manager_s * manager = NULL;
2087
2088         INIT_WFD_MGR(manager);
2089         manager = wfd_get_manager();
2090
2091         activate_handler(NULL, NULL);
2092         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2093
2094         MethodInjector *connect_method = new MethodInjector;
2095         connect_handler(connect_method->Connect(), NULL);
2096         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2097
2098         deactivate_handler(NULL, NULL);
2099         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2100
2101         wfd_manager_unload();
2102
2103         delete event;
2104         delete connect_method;
2105 }
2106
2107 TEST(wfd_mgr_connection, connect_handler_Negative4)
2108 {
2109
2110         EventInjector *event = new EventInjector;
2111         wfd_manager_s * manager = NULL;
2112
2113         INIT_WFD_MGR(manager);
2114         manager = wfd_get_manager();
2115
2116         activate_handler(NULL, NULL);
2117         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2118
2119         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2120
2121         get_connected_peers_handler(NULL, NULL);
2122
2123         MethodInjector *connect_method = new MethodInjector;
2124         connect_handler(connect_method->Connect(), NULL);
2125         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2126
2127         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
2128         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2129         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
2130         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2131         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
2132         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2133
2134         manager->max_station = 0;
2135         connect_handler(connect_method->Connect(), NULL);
2136         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2137
2138         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2139         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2140
2141         deactivate_handler(NULL, NULL);
2142         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2143
2144         wfd_manager_unload();
2145
2146         delete event;
2147         delete connect_method;
2148 }
2149
2150 TEST(wfd_mgr_connection, connect_handler_Negative5)
2151 {
2152
2153         EventInjector *event = new EventInjector;
2154         wfd_manager_s * manager = NULL;
2155
2156         INIT_WFD_MGR(manager);
2157         manager = wfd_get_manager();
2158
2159         activate_handler(NULL, NULL);
2160         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2161
2162         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2163
2164         get_connected_peers_handler(NULL, NULL);
2165
2166         MethodInjector *connect_method = new MethodInjector;
2167         connect_handler(connect_method->Connect(), NULL);
2168         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2169
2170         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
2171         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2172         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
2173         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2174         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2175
2176         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
2177         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2178
2179         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2180         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2181
2182         deactivate_handler(NULL, NULL);
2183         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2184
2185         wfd_manager_unload();
2186
2187         delete event;
2188         delete connect_method;
2189 }
2190
2191 TEST(wfd_mgr_connection, connect_handler_Negative6)
2192 {
2193
2194         EventInjector *event = new EventInjector;
2195         wfd_manager_s * manager = NULL;
2196
2197         INIT_WFD_MGR(manager);
2198         manager = wfd_get_manager();
2199
2200         activate_handler(NULL, NULL);
2201         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2202
2203         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2204
2205         get_connected_peers_handler(NULL, NULL);
2206
2207         MethodInjector *connect_method = new MethodInjector;
2208         connect_handler(connect_method->Connect(), NULL);
2209         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2210
2211         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
2212         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2213         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
2214         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2215         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2216
2217         wfd_event_key_neg_fail((wfd_oem_event_s*)event->KeyNegFailed());
2218         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2219
2220         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2221         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2222
2223         deactivate_handler(NULL, NULL);
2224         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2225
2226         wfd_manager_unload();
2227
2228         delete event;
2229         delete connect_method;
2230 }
2231
2232 TEST(wfd_mgr_connection, connect_handler_Negative7)
2233 {
2234
2235         EventInjector *event = new EventInjector;
2236         wfd_manager_s * manager = NULL;
2237
2238         INIT_WFD_MGR(manager);
2239         manager = wfd_get_manager();
2240
2241         activate_handler(NULL, NULL);
2242         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2243
2244         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2245
2246         get_connected_peers_handler(NULL, NULL);
2247
2248         MethodInjector *connect_method = new MethodInjector;
2249         connect_handler(connect_method->Connect(), NULL);
2250         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2251
2252         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
2253         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2254         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
2255
2256         wfd_event_group_formation_failure((wfd_oem_event_s*)event->GroupFormationFailed());
2257         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2258
2259         deactivate_handler(NULL, NULL);
2260         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2261
2262         wfd_manager_unload();
2263
2264         delete event;
2265         delete connect_method;
2266 }
2267
2268
2269 TEST(wfd_mgr_connection, get_connecting_peer_handler_Negative1)
2270 {
2271         get_connecting_peer_handler(NULL, NULL);
2272 }
2273
2274 TEST(wfd_mgr_connection, get_connecting_peer_handler_Negative2)
2275 {
2276         wfd_manager_s * manager = NULL;
2277
2278         INIT_WFD_MGR(manager);
2279         manager = wfd_get_manager();
2280
2281         activate_handler(NULL, NULL);
2282         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2283
2284         get_connecting_peer_handler(NULL, NULL);
2285
2286         deactivate_handler(NULL, NULL);
2287         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2288
2289         wfd_manager_unload();
2290 }
2291
2292 TEST(wfd_mgr_connection, accept_connection_Positive1)
2293 {
2294         wfd_manager_s * manager = NULL;
2295         EventInjector *event = new EventInjector;
2296
2297         INIT_WFD_MGR(manager);
2298         manager = wfd_get_manager();
2299
2300         activate_handler(NULL, NULL);
2301         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2302
2303         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcReq(false));
2304         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2305         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2306
2307         MethodInjector *accept_connect_method = new MethodInjector;
2308         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2309
2310         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2311         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
2312         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
2313
2314         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2315         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2316
2317         deactivate_handler(NULL, NULL);
2318         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2319
2320         wfd_manager_unload();
2321
2322         delete accept_connect_method;
2323         delete event;
2324 }
2325
2326 TEST(wfd_mgr_connection, accept_connection_Positive2)
2327 {
2328         wfd_manager_s * manager = NULL;
2329         EventInjector *event = new EventInjector;
2330
2331         INIT_WFD_MGR(manager);
2332         manager = wfd_get_manager();
2333
2334         activate_handler(NULL, NULL);
2335         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2336
2337         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2338         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2339
2340         MethodInjector *accept_connect_method = new MethodInjector;
2341         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2342
2343         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2344         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
2345         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
2346
2347         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2348         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2349
2350         deactivate_handler(NULL, NULL);
2351         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2352
2353         wfd_manager_unload();
2354
2355         delete accept_connect_method;
2356         delete event;
2357 }
2358
2359 TEST(wfd_mgr_connection, accept_connection_Positive3)
2360 {
2361         wfd_manager_s * manager = NULL;
2362         EventInjector *event = new EventInjector;
2363
2364         INIT_WFD_MGR(manager);
2365         manager = wfd_get_manager();
2366
2367         activate_handler(NULL, NULL);
2368         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2369
2370         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2371         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2372
2373         MethodInjector *accept_connect_method = new MethodInjector;
2374         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2375
2376         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2377         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGCwithoutIP());
2378
2379         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2380         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2381
2382         deactivate_handler(NULL, NULL);
2383         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2384
2385         wfd_manager_unload();
2386
2387         delete accept_connect_method;
2388         delete event;
2389 }
2390
2391 TEST(wfd_mgr_connection, accept_connection_Negative1)
2392 {
2393
2394         MethodInjector *accept_connect_method = new MethodInjector;
2395         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2396
2397         delete accept_connect_method;
2398 }
2399
2400 TEST(wfd_mgr_connection, accept_connection_Negative2)
2401 {
2402         wfd_manager_s * manager = NULL;
2403
2404         INIT_WFD_MGR(manager);
2405         manager = wfd_get_manager();
2406
2407         MethodInjector *accept_connect_method = new MethodInjector;
2408         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2409         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2410
2411         wfd_manager_unload();
2412
2413         delete accept_connect_method;
2414 }
2415
2416 TEST(wfd_mgr_connection, accept_connection_Negative3)
2417 {
2418         wfd_manager_s * manager = NULL;
2419
2420         INIT_WFD_MGR(manager);
2421         manager = wfd_get_manager();
2422
2423         activate_handler(NULL, NULL);
2424         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2425
2426         MethodInjector *accept_connect_method = new MethodInjector;
2427         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2428         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2429
2430         deactivate_handler(NULL, NULL);
2431         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2432
2433         wfd_manager_unload();
2434
2435         delete accept_connect_method;
2436 }
2437
2438 TEST(wfd_mgr_connection, accept_connection_Positive4)
2439 {
2440         wfd_manager_s * manager = NULL;
2441         EventInjector *event = new EventInjector;
2442
2443         INIT_WFD_MGR(manager);
2444         manager = wfd_get_manager();
2445
2446         activate_handler(NULL, NULL);
2447         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2448
2449         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2450         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2451
2452         MethodInjector *accept_connect_method = new MethodInjector;
2453         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2454
2455         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2456         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2457
2458         wfd_event_key_neg_fail((wfd_oem_event_s*)event->KeyNegFailed());
2459         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2460
2461         deactivate_handler(NULL, NULL);
2462         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2463
2464         wfd_manager_unload();
2465
2466         delete accept_connect_method;
2467         delete event;
2468 }
2469 TEST(wfd_mgr_connection, cancel_connection_handler_Positive1)
2470 {
2471         wfd_manager_s * manager = NULL;
2472         EventInjector *event = new EventInjector;
2473
2474         INIT_WFD_MGR(manager);
2475         manager = wfd_get_manager();
2476
2477         activate_handler(NULL, NULL);
2478         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2479
2480         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
2481         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2482         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2483
2484         MethodInjector *accept_connect_method = new MethodInjector;
2485         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2486
2487         MethodInjector *cancel_connect_method = new MethodInjector;
2488         cancel_connection_handler(cancel_connect_method->CancelConnect(), NULL);
2489         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2490
2491         deactivate_handler(NULL, NULL);
2492         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2493
2494         wfd_manager_unload();
2495
2496         delete event;
2497         delete accept_connect_method;
2498         delete cancel_connect_method;
2499 }
2500
2501 TEST(wfd_mgr_connection, cancel_connection_handler_Positive2)
2502 {
2503         wfd_manager_s * manager = NULL;
2504         EventInjector *event = new EventInjector;
2505
2506         INIT_WFD_MGR(manager);
2507         manager = wfd_get_manager();
2508
2509         activate_handler(NULL, NULL);
2510         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2511
2512         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
2513         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2514         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2515
2516         MethodInjector *accept_connect_method = new MethodInjector;
2517         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2518
2519         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2520
2521         MethodInjector *cancel_connect_method = new MethodInjector;
2522         cancel_connection_handler(cancel_connect_method->CancelConnect(), NULL);
2523         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2524
2525         deactivate_handler(NULL, NULL);
2526         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2527
2528         wfd_manager_unload();
2529
2530         delete event;
2531         delete accept_connect_method;
2532         delete cancel_connect_method;
2533 }
2534
2535 TEST(wfd_mgr_connection, cancel_connection_handler_Negative1)
2536 {
2537         MethodInjector *cancel_connect_method = new MethodInjector;
2538         cancel_connection_handler(cancel_connect_method->CancelConnect(), NULL);
2539
2540         delete cancel_connect_method;
2541 }
2542
2543 TEST(wfd_mgr_connection, cancel_connection_handler_Negative2)
2544 {
2545         wfd_manager_s * manager = NULL;
2546
2547         INIT_WFD_MGR(manager);
2548         manager = wfd_get_manager();
2549
2550         MethodInjector *cancel_connect_method = new MethodInjector;
2551         cancel_connection_handler(cancel_connect_method->CancelConnect(), NULL);
2552         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2553
2554         wfd_manager_unload();
2555
2556         delete cancel_connect_method;
2557 }
2558
2559 TEST(wfd_mgr_connection, reject_connection_handler_Positive)
2560 {
2561         wfd_manager_s * manager = NULL;
2562         EventInjector *event = new EventInjector;
2563
2564         INIT_WFD_MGR(manager);
2565         manager = wfd_get_manager();
2566
2567         activate_handler(NULL, NULL);
2568         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2569
2570         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
2571         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2572
2573         MethodInjector *reject_connect_method = new MethodInjector;
2574         reject_connection_handler(reject_connect_method->RejectConnect(), NULL);
2575
2576         deactivate_handler(NULL, NULL);
2577         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2578
2579         wfd_manager_unload();
2580
2581         delete event;
2582         delete reject_connect_method;
2583 }
2584
2585 TEST(wfd_mgr_connection, reject_connection_handler_Negative1)
2586 {
2587
2588         MethodInjector *reject_connect_method = new MethodInjector;
2589         reject_connection_handler(reject_connect_method->RejectConnect(), NULL);
2590
2591         delete reject_connect_method;
2592 }
2593
2594 TEST(wfd_mgr_connection, reject_connection_handler_Negative2)
2595 {
2596         wfd_manager_s * manager = NULL;
2597
2598         INIT_WFD_MGR(manager);
2599         manager = wfd_get_manager();
2600
2601         MethodInjector *reject_connect_method = new MethodInjector;
2602         reject_connection_handler(reject_connect_method->RejectConnect(), NULL);
2603
2604         wfd_manager_unload();
2605
2606         delete reject_connect_method;
2607 }
2608
2609 TEST(wfd_mgr_connection, reject_connection_handler_Negative3)
2610 {
2611         wfd_manager_s * manager = NULL;
2612
2613         INIT_WFD_MGR(manager);
2614         manager = wfd_get_manager();
2615
2616         activate_handler(NULL, NULL);
2617         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2618
2619         MethodInjector *connect_method = new MethodInjector;
2620         connect_handler(connect_method->Connect(), NULL);
2621
2622         MethodInjector *reject_connect_method = new MethodInjector;
2623         reject_connection_handler(reject_connect_method->RejectConnect(), NULL);
2624
2625         deactivate_handler(NULL, NULL);
2626         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2627
2628         wfd_manager_unload();
2629
2630         delete reject_connect_method;
2631         delete connect_method;
2632 }
2633
2634 TEST(wfd_mgr_connection, disconnect_handler_Positive1)
2635 {
2636         wfd_manager_s * manager = NULL;
2637         EventInjector *event = new EventInjector;
2638
2639         INIT_WFD_MGR(manager);
2640         manager = wfd_get_manager();
2641
2642         activate_handler(NULL, NULL);
2643         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2644
2645         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2646
2647         MethodInjector *connect_method = new MethodInjector;
2648         connect_handler(connect_method->Connect(), NULL);
2649         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2650
2651         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
2652         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2653         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
2654         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2655         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
2656         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2657
2658         MethodInjector *find_method = new MethodInjector;
2659         start_discovery_handler(find_method->StartDiscoveryFind(), NULL);
2660         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2661
2662         MethodInjector *peer_addr = new MethodInjector;
2663         disconnect_handler(peer_addr->GetPeerAddr(), NULL);
2664
2665         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
2666         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2667
2668         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2669         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2670
2671         deactivate_handler(NULL, NULL);
2672         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2673
2674         wfd_manager_unload();
2675
2676         delete connect_method;
2677         delete find_method;
2678         delete event;
2679         delete peer_addr;
2680 }
2681
2682 TEST(wfd_mgr_connection, disconnect_handler_Positive2)
2683 {
2684         wfd_manager_s * manager = NULL;
2685         EventInjector *event = new EventInjector;
2686
2687         INIT_WFD_MGR(manager);
2688         manager = wfd_get_manager();
2689
2690         activate_handler(NULL, NULL);
2691         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2692
2693         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcReq(false));
2694         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2695         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2696
2697         MethodInjector *accept_connect_method = new MethodInjector;
2698         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2699
2700         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2701         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
2702         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
2703
2704         MethodInjector *find_method = new MethodInjector;
2705         start_discovery_handler(find_method->StartDiscoveryFind(), NULL);
2706         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
2707
2708         MethodInjector *peer_addr = new MethodInjector;
2709         disconnect_handler(peer_addr->GetPeerAddr(), NULL);
2710
2711         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2712         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2713
2714         deactivate_handler(NULL, NULL);
2715         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2716
2717         wfd_manager_unload();
2718
2719         delete accept_connect_method;
2720         delete find_method;
2721         delete event;
2722         delete peer_addr;
2723 }
2724
2725 TEST(wfd_mgr_connection, disconnect_handler_Negative1)
2726 {
2727         MethodInjector *peer_addr = new MethodInjector;
2728         disconnect_handler(peer_addr->GetPeerAddr(), NULL);
2729
2730         delete peer_addr;
2731 }
2732
2733 TEST(wfd_mgr_connection, disconnect_handler_Negative2)
2734 {
2735         wfd_manager_s * manager = NULL;
2736
2737         INIT_WFD_MGR(manager);
2738         manager = wfd_get_manager();
2739
2740         MethodInjector *peer_addr = new MethodInjector;
2741         disconnect_handler(peer_addr->GetPeerAddr(), NULL);
2742
2743         wfd_manager_unload();
2744
2745         delete peer_addr;
2746 }
2747 TEST(wfd_mgr_connection, disconnect_all_handler_Positive1)
2748 {
2749         wfd_manager_s * manager = NULL;
2750         EventInjector *event = new EventInjector;
2751
2752         INIT_WFD_MGR(manager);
2753         manager = wfd_get_manager();
2754
2755         activate_handler(NULL, NULL);
2756         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2757
2758         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2759
2760         MethodInjector *connect_method = new MethodInjector;
2761         connect_handler(connect_method->Connect(), NULL);
2762         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2763
2764         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
2765         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2766         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
2767         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2768         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
2769         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2770
2771         MethodInjector *find_method = new MethodInjector;
2772         start_discovery_handler(find_method->StartDiscoveryFind(), NULL);
2773         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2774
2775         disconnect_all_handler(NULL, NULL);
2776         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2777
2778         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2779         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2780
2781         deactivate_handler(NULL, NULL);
2782         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2783
2784         wfd_manager_unload();
2785
2786         delete connect_method;
2787         delete find_method;
2788         delete event;
2789 }
2790
2791 TEST(wfd_mgr_connection, disconnect_all_handler_Positive2)
2792 {
2793         wfd_manager_s * manager = NULL;
2794         EventInjector *event = new EventInjector;
2795
2796         INIT_WFD_MGR(manager);
2797         manager = wfd_get_manager();
2798
2799         activate_handler(NULL, NULL);
2800         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2801
2802         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcReq(false));
2803         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
2804         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2805
2806         MethodInjector *accept_connect_method = new MethodInjector;
2807         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2808
2809         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
2810         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
2811         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
2812
2813         MethodInjector *find_method = new MethodInjector;
2814         start_discovery_handler(find_method->StartDiscoveryFind(), NULL);
2815         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
2816
2817         disconnect_all_handler(NULL, NULL);
2818         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2819
2820         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2821         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2822
2823         deactivate_handler(NULL, NULL);
2824         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2825
2826         wfd_manager_unload();
2827
2828         delete accept_connect_method;
2829         delete find_method;
2830         delete event;
2831 }
2832
2833 TEST(wfd_mgr_connection, disconnect_all_handler_Negative1)
2834 {
2835         disconnect_all_handler(NULL, NULL);
2836 }
2837
2838 TEST(wfd_mgr_connection, disconnect_all_handler_Negative2)
2839 {
2840         wfd_manager_s * manager = NULL;
2841
2842         INIT_WFD_MGR(manager);
2843         manager = wfd_get_manager();
2844
2845         disconnect_all_handler(NULL, NULL);
2846
2847         wfd_manager_unload();
2848 }
2849
2850 TEST(wfd_mgr_connection, legacy_connection_Positive)
2851 {
2852         wfd_manager_s * manager = NULL;
2853         EventInjector *event = new EventInjector;
2854
2855         INIT_WFD_MGR(manager);
2856         manager = wfd_get_manager();
2857
2858         activate_handler(NULL, NULL);
2859         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2860
2861         MethodInjector *group_create_method = new MethodInjector;
2862         create_group_handler(group_create_method->CreateGroup(), NULL);
2863
2864         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2865         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2866
2867         wfd_event_sta_connected((wfd_oem_event_s*)event->LegacyPeerJoined());
2868         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2869
2870         wfd_event_sta_disconnected((wfd_oem_event_s*)event->LegacyPeerDisconnected());
2871         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2872
2873         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2874         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2875
2876         deactivate_handler(NULL, NULL);
2877         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2878
2879         wfd_manager_unload();
2880
2881         delete group_create_method;
2882         delete event;
2883 }
2884
2885
2886 TEST(wfd_mgr_connection, multi_connect_Positive)
2887 {
2888         wfd_manager_s * manager = NULL;
2889         EventInjector *event = new EventInjector;
2890
2891         INIT_WFD_MGR(manager);
2892         manager = wfd_get_manager();
2893
2894         activate_handler(NULL, NULL);
2895         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2896
2897         MethodInjector *group_create_method = new MethodInjector;
2898         create_group_handler(group_create_method->CreateGroup(), NULL);
2899
2900         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2901         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2902
2903         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2904         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
2905         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2906
2907         MethodInjector *accept_connect_method = new MethodInjector;
2908         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
2909
2910         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
2911         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2912
2913         wfd_event_sta_connected((wfd_oem_event_s*)event->LegacyPeerJoined());
2914         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2915
2916         MethodInjector *peer_addr = new MethodInjector;
2917         disconnect_handler(peer_addr->GetPeerAddr(), NULL);
2918
2919         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
2920         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2921
2922         wfd_event_sta_disconnected((wfd_oem_event_s*)event->LegacyPeerDisconnected());
2923         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2924
2925         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2926         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2927
2928         deactivate_handler(NULL, NULL);
2929         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2930
2931         wfd_manager_unload();
2932
2933         delete group_create_method;
2934         delete accept_connect_method;
2935         delete peer_addr;
2936         delete event;
2937 }
2938
2939
2940 TEST(wfd_mgr_connection_fail, wfd_event_prov_disc_fail_Positive1)
2941 {
2942         EventInjector *event = new EventInjector;
2943         wfd_manager_s * manager = NULL;
2944
2945         INIT_WFD_MGR(manager);
2946         manager = wfd_get_manager();
2947
2948         activate_handler(NULL, NULL);
2949         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2950
2951         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2952
2953         MethodInjector *connect_method = new MethodInjector;
2954         connect_handler(connect_method->Connect(), NULL);
2955         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2956
2957         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->ProvFailure());
2958         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2959
2960         deactivate_handler(NULL, NULL);
2961         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
2962
2963         wfd_manager_unload();
2964
2965         delete event;
2966         delete connect_method;
2967 }
2968
2969 TEST(wfd_mgr_connection_fail, wfd_event_prov_disc_fail_Positive2)
2970 {
2971         wfd_manager_s * manager = NULL;
2972         EventInjector *event = new EventInjector;
2973
2974         INIT_WFD_MGR(manager);
2975         manager = wfd_get_manager();
2976
2977         activate_handler(NULL, NULL);
2978         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2979
2980         MethodInjector *group_create_method = new MethodInjector;
2981         create_group_handler(group_create_method->CreateGroup(), NULL);
2982
2983         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
2984         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
2985
2986         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
2987
2988         MethodInjector *connect_method = new MethodInjector;
2989         connect_handler(connect_method->Connect(), NULL);
2990         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
2991
2992         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->ProvFailure());
2993         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2994
2995         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
2996         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
2997
2998         deactivate_handler(NULL, NULL);
2999         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3000
3001         wfd_manager_unload();
3002
3003         delete group_create_method;
3004         delete connect_method;
3005         delete event;
3006 }
3007
3008 TEST(wfd_mgr_connection_fail, wfd_event_prov_disc_fail_Positive3)
3009 {
3010         wfd_manager_s * manager = NULL;
3011         EventInjector *event = new EventInjector;
3012
3013         INIT_WFD_MGR(manager);
3014         manager = wfd_get_manager();
3015
3016         activate_handler(NULL, NULL);
3017         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3018
3019         MethodInjector *group_create_method = new MethodInjector;
3020         create_group_handler(group_create_method->CreateGroup(), NULL);
3021
3022         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3023         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3024
3025         wfd_event_sta_connected((wfd_oem_event_s*)event->LegacyPeerJoined());
3026         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3027
3028         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3029
3030         MethodInjector *connect_method = new MethodInjector;
3031         connect_handler(connect_method->Connect(), NULL);
3032         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3033
3034         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->ProvFailure());
3035         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3036
3037         wfd_event_sta_disconnected((wfd_oem_event_s*)event->LegacyPeerDisconnected());
3038         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3039
3040         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3041         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3042
3043         deactivate_handler(NULL, NULL);
3044         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3045
3046         wfd_manager_unload();
3047
3048         delete group_create_method;
3049         delete connect_method;
3050         delete event;
3051 }
3052
3053 TEST(wfd_mgr_connection_fail, wfd_event_prov_disc_fail_Negative1)
3054 {
3055         EventInjector *event = new EventInjector;
3056         wfd_manager_s * manager = NULL;
3057
3058         INIT_WFD_MGR(manager);
3059         manager = wfd_get_manager();
3060
3061         activate_handler(NULL, NULL);
3062         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3063
3064         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->ProvFailure());
3065         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3066
3067         deactivate_handler(NULL, NULL);
3068         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3069
3070         wfd_manager_unload();
3071
3072         delete event;
3073 }
3074
3075 TEST(wfd_mgr_connection, wfd_event_go_neg_fail_Positive)
3076 {
3077         wfd_manager_s * manager = NULL;
3078         EventInjector *event = new EventInjector;
3079
3080         INIT_WFD_MGR(manager);
3081         manager = wfd_get_manager();
3082
3083         activate_handler(NULL, NULL);
3084         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3085
3086         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcReq(false));
3087         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
3088         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3089
3090         MethodInjector *accept_connect_method = new MethodInjector;
3091         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3092
3093         wfd_event_go_neg_fail((wfd_oem_event_s*)event->GoNegFailure());
3094         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3095
3096         deactivate_handler(NULL, NULL);
3097         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3098
3099         wfd_manager_unload();
3100
3101         delete accept_connect_method;
3102         delete event;
3103 }
3104
3105 TEST(wfd_mgr_connection, wfd_event_go_neg_fail_Negative)
3106 {
3107         wfd_manager_s * manager = NULL;
3108         EventInjector *event = new EventInjector;
3109
3110         INIT_WFD_MGR(manager);
3111         manager = wfd_get_manager();
3112
3113         activate_handler(NULL, NULL);
3114         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3115
3116         wfd_event_go_neg_fail((wfd_oem_event_s*)event->GoNegFailure());
3117         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3118
3119         deactivate_handler(NULL, NULL);
3120         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3121
3122         wfd_manager_unload();
3123
3124         delete event;
3125 }
3126
3127 TEST(wfd_mgr_connection_fail, wfd_event_wps_fail_Positive1)
3128 {
3129         EventInjector *event = new EventInjector;
3130         wfd_manager_s * manager = NULL;
3131
3132         INIT_WFD_MGR(manager);
3133         manager = wfd_get_manager();
3134
3135         activate_handler(NULL, NULL);
3136         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3137
3138         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3139
3140         MethodInjector *connect_method = new MethodInjector;
3141         connect_handler(connect_method->Connect(), NULL);
3142         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3143
3144         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
3145         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
3146         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
3147
3148         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3149
3150         wfd_event_wps_fail((wfd_oem_event_s*)event->WpsFailed());
3151         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3152
3153         deactivate_handler(NULL, NULL);
3154         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3155
3156         wfd_manager_unload();
3157
3158         delete event;
3159         delete connect_method;
3160 }
3161
3162 TEST(wfd_mgr_connection_fail, wfd_event_wps_fail_Positive2)
3163 {
3164         wfd_manager_s * manager = NULL;
3165         EventInjector *event = new EventInjector;
3166
3167         INIT_WFD_MGR(manager);
3168         manager = wfd_get_manager();
3169
3170         activate_handler(NULL, NULL);
3171         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3172
3173         MethodInjector *group_create_method = new MethodInjector;
3174         create_group_handler(group_create_method->CreateGroup(), NULL);
3175
3176         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3177         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3178
3179         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3180
3181         MethodInjector *connect_method = new MethodInjector;
3182         connect_handler(connect_method->Connect(), NULL);
3183         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3184
3185         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
3186
3187         wfd_event_wps_fail((wfd_oem_event_s*)event->WpsFailed());
3188         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3189
3190         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3191         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3192
3193         deactivate_handler(NULL, NULL);
3194         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3195
3196         wfd_manager_unload();
3197
3198         delete group_create_method;
3199         delete connect_method;
3200         delete event;
3201 }
3202
3203 TEST(wfd_mgr_connection_fail, wfd_event_wps_fail_Positive3)
3204 {
3205         wfd_manager_s * manager = NULL;
3206         EventInjector *event = new EventInjector;
3207
3208         INIT_WFD_MGR(manager);
3209         manager = wfd_get_manager();
3210
3211         activate_handler(NULL, NULL);
3212         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3213
3214         MethodInjector *group_create_method = new MethodInjector;
3215         create_group_handler(group_create_method->CreateGroup(), NULL);
3216
3217         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3218         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3219
3220         wfd_event_sta_connected((wfd_oem_event_s*)event->LegacyPeerJoined());
3221         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3222
3223         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3224
3225         MethodInjector *connect_method = new MethodInjector;
3226         connect_handler(connect_method->Connect(), NULL);
3227         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3228
3229         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
3230
3231         wfd_event_wps_fail((wfd_oem_event_s*)event->WpsFailed());
3232         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3233
3234         wfd_event_sta_disconnected((wfd_oem_event_s*)event->LegacyPeerDisconnected());
3235         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3236
3237         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3238         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3239
3240         deactivate_handler(NULL, NULL);
3241         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3242
3243         wfd_manager_unload();
3244
3245         delete group_create_method;
3246         delete connect_method;
3247         delete event;
3248 }
3249
3250 TEST(wfd_mgr_connection_fail, wfd_event_wps_fail_Negative1)
3251 {
3252         EventInjector *event = new EventInjector;
3253         wfd_manager_s * manager = NULL;
3254
3255         INIT_WFD_MGR(manager);
3256         manager = wfd_get_manager();
3257
3258         activate_handler(NULL, NULL);
3259         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3260
3261         wfd_event_wps_fail((wfd_oem_event_s*)event->WpsFailed());
3262         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3263
3264         deactivate_handler(NULL, NULL);
3265         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3266
3267         wfd_manager_unload();
3268
3269         delete event;
3270 }
3271
3272 TEST(wfd_mgr_connect_pbc, pbc_connection_Positive1)
3273 {
3274         EventInjector *event = new EventInjector;
3275         wfd_manager_s * manager = NULL;
3276
3277         INIT_WFD_MGR(manager);
3278         manager = wfd_get_manager();
3279
3280         activate_handler(NULL, NULL);
3281         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3282
3283         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3284
3285         MethodInjector *connect_method = new MethodInjector;
3286         connect_handler(connect_method->Connect(), NULL);
3287         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3288
3289         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(false));
3290         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
3291         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
3292         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3293         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3294         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3295
3296         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3297         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3298
3299         deactivate_handler(NULL, NULL);
3300         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3301
3302         wfd_manager_unload();
3303
3304         delete event;
3305         delete connect_method;
3306 }
3307
3308 TEST(wfd_mgr_connect_pbc, pbc_connection_Positive2)
3309 {
3310         wfd_manager_s * manager = NULL;
3311         EventInjector *event = new EventInjector;
3312
3313         INIT_WFD_MGR(manager);
3314         manager = wfd_get_manager();
3315
3316         activate_handler(NULL, NULL);
3317         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3318
3319         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
3320         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestPbc());
3321         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3322
3323         MethodInjector *accept_connect_method = new MethodInjector;
3324         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3325
3326         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
3327         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3328         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3329
3330         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3331         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3332
3333         deactivate_handler(NULL, NULL);
3334         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3335
3336         wfd_manager_unload();
3337
3338         delete accept_connect_method;
3339         delete event;
3340 }
3341
3342 TEST(wfd_mgr_connect_pbc, pbc_connection_Positive3)
3343 {
3344         wfd_manager_s * manager = NULL;
3345         EventInjector *event = new EventInjector;
3346
3347         INIT_WFD_MGR(manager);
3348         manager = wfd_get_manager();
3349
3350         activate_handler(NULL, NULL);
3351         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3352
3353         wfd_event_peer_found((wfd_oem_event_s *)event->GoFound());
3354
3355         MethodInjector *connect_method = new MethodInjector;
3356         connect_handler(connect_method->Connect(), NULL);
3357         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3358
3359         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(true));
3360         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3361         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3362
3363         destroy_group_handler(NULL, NULL);
3364
3365         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3366         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3367
3368         deactivate_handler(NULL, NULL);
3369         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3370
3371
3372         wfd_manager_unload();
3373
3374         delete event;
3375         delete connect_method;
3376 }
3377
3378 TEST(wfd_mgr_connect_pbc, pbc_connection_Positive4)
3379 {
3380         wfd_manager_s * manager = NULL;
3381         EventInjector *event = new EventInjector;
3382
3383         INIT_WFD_MGR(manager);
3384         manager = wfd_get_manager();
3385
3386         activate_handler(NULL, NULL);
3387         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3388
3389         wfd_event_invitation_req((wfd_oem_event_s*)event->InvitationReceived());
3390         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3391
3392         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvPbcResp(true));
3393
3394         MethodInjector *accept_connect_method = new MethodInjector;
3395         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3396
3397         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3398         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3399
3400         destroy_group_handler(NULL, NULL);
3401
3402         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3403         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3404
3405         deactivate_handler(NULL, NULL);
3406         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3407
3408         wfd_manager_unload();
3409
3410         delete accept_connect_method;
3411         delete event;
3412 }
3413
3414 TEST(wfd_mgr_connect_pbc, pbc_connection_Positive5)
3415 {
3416         wfd_manager_s * manager = NULL;
3417         EventInjector *event = new EventInjector;
3418
3419         INIT_WFD_MGR(manager);
3420         manager = wfd_get_manager();
3421
3422         activate_handler(NULL, NULL);
3423         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3424
3425         MethodInjector *group_create_method = new MethodInjector;
3426         create_group_handler(group_create_method->CreateGroup(), NULL);
3427
3428         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3429         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3430
3431         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3432
3433         MethodInjector *connect_method = new MethodInjector;
3434         connect_handler(connect_method->Connect(), NULL);
3435         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3436
3437         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
3438         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3439         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3440
3441         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
3442         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3443         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3444
3445         deactivate_handler(NULL, NULL);
3446         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3447
3448         wfd_manager_unload();
3449
3450         delete event;
3451         delete group_create_method;
3452         delete connect_method;
3453 }
3454
3455 TEST(wfd_mgr_connect_pbc, pbc_connection_Positive6)
3456 {
3457         wfd_manager_s * manager = NULL;
3458         EventInjector *event = new EventInjector;
3459
3460         INIT_WFD_MGR(manager);
3461         manager = wfd_get_manager();
3462
3463         activate_handler(NULL, NULL);
3464         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3465
3466         MethodInjector *group_create_method = new MethodInjector;
3467         create_group_handler(group_create_method->CreateGroup(), NULL);
3468
3469         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3470         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3471
3472         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvPbcReq(false));
3473
3474         MethodInjector *accept_connect_method = new MethodInjector;
3475         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3476         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3477
3478         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3479         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3480
3481         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
3482         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3483         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3484
3485         deactivate_handler(NULL, NULL);
3486         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3487
3488         wfd_manager_unload();
3489
3490         delete event;
3491         delete group_create_method;
3492         delete accept_connect_method;
3493 }
3494
3495 TEST(wfd_mgr_connect_keypad, keypad_connection_Positive1)
3496 {
3497         EventInjector *event = new EventInjector;
3498         wfd_manager_s * manager = NULL;
3499         int wps_mode = WFD_WPS_MODE_DISPLAY;
3500
3501         INIT_WFD_MGR(manager);
3502         manager = wfd_get_manager();
3503
3504         activate_handler(NULL, NULL);
3505         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3506
3507         MethodInjector *set_req_wps_method = new MethodInjector;
3508         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
3509
3510         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3511
3512         MethodInjector *connect_method = new MethodInjector;
3513         connect_handler(connect_method->Connect(), NULL);
3514         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3515
3516         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvRespEnterPin(false));
3517
3518         get_local_wps_mode_handler(NULL, NULL);
3519
3520         MethodInjector *set_wps_pin_method = new MethodInjector;
3521         set_wps_pin_handler(set_wps_pin_method->SetWpsPin(), NULL);
3522
3523         MethodInjector *accept_connect_method = new MethodInjector;
3524         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3525
3526         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestKeypad());
3527         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
3528         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3529         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3530         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3531
3532         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3533         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3534
3535         deactivate_handler(NULL, NULL);
3536         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3537
3538         wfd_manager_unload();
3539
3540         delete event;
3541         delete connect_method;
3542         delete accept_connect_method;
3543         delete set_wps_pin_method;
3544         delete set_req_wps_method;
3545 }
3546
3547 TEST(wfd_mgr_connect_keypad, keypad_connection_Positive2)
3548 {
3549         wfd_manager_s * manager = NULL;
3550         EventInjector *event = new EventInjector;
3551
3552         INIT_WFD_MGR(manager);
3553         manager = wfd_get_manager();
3554
3555         activate_handler(NULL, NULL);
3556         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3557
3558         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvReqEnterPin(false));
3559         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestKeypad());
3560         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3561
3562         get_local_wps_mode_handler(NULL, NULL);
3563
3564         MethodInjector *set_wps_pin_method = new MethodInjector;
3565         set_wps_pin_handler(set_wps_pin_method->SetWpsPin(), NULL);
3566
3567         MethodInjector *accept_connect_method = new MethodInjector;
3568         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3569
3570         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
3571         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3572         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3573
3574         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3575         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3576
3577         deactivate_handler(NULL, NULL);
3578         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3579
3580         wfd_manager_unload();
3581
3582         delete event;
3583         delete set_wps_pin_method;
3584         delete accept_connect_method;
3585 }
3586
3587 TEST(wfd_mgr_connect_keypad, keypad_connection_Positive3)
3588 {
3589         wfd_manager_s * manager = NULL;
3590         EventInjector *event = new EventInjector;
3591         int wps_mode = WFD_WPS_MODE_DISPLAY;
3592
3593         INIT_WFD_MGR(manager);
3594         manager = wfd_get_manager();
3595
3596         activate_handler(NULL, NULL);
3597         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3598
3599         MethodInjector *set_req_wps_method = new MethodInjector;
3600         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
3601
3602         wfd_event_peer_found((wfd_oem_event_s *)event->GoFound());
3603
3604         MethodInjector *connect_method = new MethodInjector;
3605         connect_handler(connect_method->Connect(), NULL);
3606         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3607
3608         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvRespEnterPin(true));
3609
3610         get_local_wps_mode_handler(NULL, NULL);
3611
3612         MethodInjector *set_wps_pin_method = new MethodInjector;
3613         set_wps_pin_handler(set_wps_pin_method->SetWpsPin(), NULL);
3614
3615         MethodInjector *accept_connect_method = new MethodInjector;
3616         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3617
3618         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3619         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3620
3621         destroy_group_handler(NULL, NULL);
3622
3623         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3624         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3625
3626         deactivate_handler(NULL, NULL);
3627         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3628
3629
3630         wfd_manager_unload();
3631
3632         delete event;
3633         delete connect_method;
3634         delete set_req_wps_method;
3635         delete set_wps_pin_method;
3636         delete accept_connect_method;
3637 }
3638
3639 TEST(wfd_mgr_connect_keypad, keypad_connection_Positive4)
3640 {
3641         wfd_manager_s * manager = NULL;
3642         EventInjector *event = new EventInjector;
3643         int wps_mode = WFD_WPS_MODE_DISPLAY;
3644
3645         INIT_WFD_MGR(manager);
3646         manager = wfd_get_manager();
3647
3648         activate_handler(NULL, NULL);
3649         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3650
3651         MethodInjector *set_req_wps_method = new MethodInjector;
3652         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
3653
3654         wfd_event_invitation_req((wfd_oem_event_s*)event->InvitationReceived());
3655         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3656
3657         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvRespEnterPin(true));
3658
3659         get_local_wps_mode_handler(NULL, NULL);
3660
3661         MethodInjector *set_wps_pin_method = new MethodInjector;
3662         set_wps_pin_handler(set_wps_pin_method->SetWpsPin(), NULL);
3663
3664         MethodInjector *accept_connect_method = new MethodInjector;
3665         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3666
3667         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3668         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3669
3670         destroy_group_handler(NULL, NULL);
3671
3672         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3673         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3674
3675         deactivate_handler(NULL, NULL);
3676         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3677
3678         wfd_manager_unload();
3679
3680         delete set_req_wps_method;
3681         delete accept_connect_method;
3682         delete set_wps_pin_method;
3683         delete event;
3684 }
3685
3686 TEST(wfd_mgr_connect_keypad, keypad_connection_Positive5)
3687 {
3688         wfd_manager_s * manager = NULL;
3689         EventInjector *event = new EventInjector;
3690
3691         INIT_WFD_MGR(manager);
3692         manager = wfd_get_manager();
3693
3694         activate_handler(NULL, NULL);
3695         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3696
3697         MethodInjector *group_create_method = new MethodInjector;
3698         create_group_handler(group_create_method->CreateGroup(), NULL);
3699
3700         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3701         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3702
3703         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3704
3705         MethodInjector *connect_method = new MethodInjector;
3706         connect_handler(connect_method->Connect(), NULL);
3707         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3708
3709         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvReqEnterPin(true));
3710
3711         get_local_wps_mode_handler(NULL, NULL);
3712
3713         MethodInjector *set_wps_pin_method = new MethodInjector;
3714         set_wps_pin_handler(set_wps_pin_method->SetWpsPin(), NULL);
3715
3716         MethodInjector *accept_connect_method = new MethodInjector;
3717         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3718
3719         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3720         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3721
3722         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
3723         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3724         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3725
3726         deactivate_handler(NULL, NULL);
3727         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3728
3729         wfd_manager_unload();
3730
3731         delete event;
3732         delete group_create_method;
3733         delete connect_method;
3734         delete accept_connect_method;
3735         delete set_wps_pin_method;
3736 }
3737
3738 TEST(wfd_mgr_connect_keypad, keypad_connection_Positive6)
3739 {
3740         wfd_manager_s * manager = NULL;
3741         EventInjector *event = new EventInjector;
3742
3743         INIT_WFD_MGR(manager);
3744         manager = wfd_get_manager();
3745
3746         activate_handler(NULL, NULL);
3747         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3748
3749         MethodInjector *group_create_method = new MethodInjector;
3750         create_group_handler(group_create_method->CreateGroup(), NULL);
3751
3752         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3753         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3754
3755         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvReqEnterPin(true));
3756
3757         get_local_wps_mode_handler(NULL, NULL);
3758
3759         MethodInjector *set_wps_pin_method = new MethodInjector;
3760         set_wps_pin_handler(set_wps_pin_method->SetWpsPin(), NULL);
3761
3762         MethodInjector *accept_connect_method = new MethodInjector;
3763         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3764
3765         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3766         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3767
3768         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
3769         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3770         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3771
3772         deactivate_handler(NULL, NULL);
3773         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3774
3775         wfd_manager_unload();
3776
3777         delete event;
3778         delete group_create_method;
3779         delete set_wps_pin_method;
3780         delete accept_connect_method;
3781 }
3782
3783 TEST(wfd_mgr_connect_display, display_connection_Positive1)
3784 {
3785         EventInjector *event = new EventInjector;
3786         wfd_manager_s * manager = NULL;
3787         int wps_mode = WFD_WPS_MODE_KEYPAD;
3788
3789         INIT_WFD_MGR(manager);
3790         manager = wfd_get_manager();
3791
3792         activate_handler(NULL, NULL);
3793         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3794
3795         MethodInjector *set_req_wps_method = new MethodInjector;
3796         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
3797
3798         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3799
3800         MethodInjector *connect_method = new MethodInjector;
3801         connect_handler(connect_method->Connect(), NULL);
3802         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3803
3804         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvRespDisplayPin(false));
3805
3806         get_local_wps_mode_handler(NULL, NULL);
3807         get_wps_pin_handler(NULL, NULL);
3808
3809         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestDisplay());
3810         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGo());
3811         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3812         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3813         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3814
3815         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3816         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3817
3818         deactivate_handler(NULL, NULL);
3819         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3820
3821         wfd_manager_unload();
3822
3823         delete event;
3824         delete connect_method;
3825         delete set_req_wps_method;
3826 }
3827
3828 TEST(wfd_mgr_connect_display, display_connection_Positive2)
3829 {
3830         wfd_manager_s * manager = NULL;
3831         EventInjector *event = new EventInjector;
3832
3833         INIT_WFD_MGR(manager);
3834         manager = wfd_get_manager();
3835
3836         activate_handler(NULL, NULL);
3837         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3838
3839         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvReqDisplayPin(false));
3840         wfd_event_go_neg_req((wfd_oem_event_s*)event->GoNegRequestDisplay());
3841         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3842
3843         get_local_wps_mode_handler(NULL, NULL);
3844         get_wps_pin_handler(NULL, NULL);
3845
3846         MethodInjector *accept_connect_method = new MethodInjector;
3847         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3848
3849         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
3850         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3851         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3852
3853         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3854         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3855
3856         deactivate_handler(NULL, NULL);
3857         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3858
3859         wfd_manager_unload();
3860
3861         delete accept_connect_method;
3862         delete event;
3863 }
3864
3865 TEST(wfd_mgr_connect_display, display_connection_Positive3)
3866 {
3867         wfd_manager_s * manager = NULL;
3868         EventInjector *event = new EventInjector;
3869         int wps_mode = WFD_WPS_MODE_KEYPAD;
3870
3871         INIT_WFD_MGR(manager);
3872         manager = wfd_get_manager();
3873
3874         activate_handler(NULL, NULL);
3875         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3876
3877         MethodInjector *set_req_wps_method = new MethodInjector;
3878         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
3879
3880         wfd_event_peer_found((wfd_oem_event_s *)event->GoFound());
3881
3882         MethodInjector *connect_method = new MethodInjector;
3883         connect_handler(connect_method->Connect(), NULL);
3884         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3885
3886         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvRespDisplayPin(true));
3887
3888         get_local_wps_mode_handler(NULL, NULL);
3889         get_wps_pin_handler(NULL, NULL);
3890
3891         get_wps_pin_handler(NULL, NULL);
3892
3893         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3894         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3895
3896         destroy_group_handler(NULL, NULL);
3897
3898         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3899         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3900
3901         deactivate_handler(NULL, NULL);
3902         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3903
3904
3905         wfd_manager_unload();
3906
3907         delete event;
3908         delete connect_method;
3909         delete set_req_wps_method;
3910 }
3911
3912 TEST(wfd_mgr_connect_display, display_connection_Positive4)
3913 {
3914         wfd_manager_s * manager = NULL;
3915         EventInjector *event = new EventInjector;
3916         int wps_mode = WFD_WPS_MODE_KEYPAD;
3917
3918         INIT_WFD_MGR(manager);
3919         manager = wfd_get_manager();
3920
3921         activate_handler(NULL, NULL);
3922         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3923
3924         MethodInjector *set_req_wps_method = new MethodInjector;
3925         set_req_wps_mode_handler(set_req_wps_method->SetReqWpsMode(wps_mode), NULL);
3926
3927         wfd_event_invitation_req((wfd_oem_event_s*)event->InvitationReceived());
3928         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3929
3930         wfd_event_prov_disc_resp((wfd_oem_event_s*)event->ProvRespDisplayPin(true));
3931
3932         MethodInjector *accept_connect_method = new MethodInjector;
3933         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
3934
3935         get_local_wps_mode_handler(NULL, NULL);
3936         get_wps_pin_handler(NULL, NULL);
3937
3938         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
3939         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
3940
3941         destroy_group_handler(NULL, NULL);
3942
3943         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3944         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3945
3946         deactivate_handler(NULL, NULL);
3947         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3948
3949         wfd_manager_unload();
3950
3951         delete set_req_wps_method;
3952         delete accept_connect_method;
3953         delete event;
3954 }
3955
3956 TEST(wfd_mgr_connect_display, display_connection_Positive5)
3957 {
3958         wfd_manager_s * manager = NULL;
3959         EventInjector *event = new EventInjector;
3960
3961         INIT_WFD_MGR(manager);
3962         manager = wfd_get_manager();
3963
3964         activate_handler(NULL, NULL);
3965         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3966
3967         MethodInjector *group_create_method = new MethodInjector;
3968         create_group_handler(group_create_method->CreateGroup(), NULL);
3969
3970         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
3971         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3972
3973         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
3974
3975         MethodInjector *connect_method = new MethodInjector;
3976         connect_handler(connect_method->Connect(), NULL);
3977         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
3978
3979         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvReqDisplayPin(false));
3980
3981         get_local_wps_mode_handler(NULL, NULL);
3982         get_wps_pin_handler(NULL, NULL);
3983
3984         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
3985         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
3986
3987         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
3988         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
3989         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
3990
3991         deactivate_handler(NULL, NULL);
3992         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
3993
3994         wfd_manager_unload();
3995
3996         delete event;
3997         delete group_create_method;
3998         delete connect_method;
3999 }
4000
4001 TEST(wfd_mgr_connect_display, display_connection_Positive6)
4002 {
4003         wfd_manager_s * manager = NULL;
4004         EventInjector *event = new EventInjector;
4005
4006         INIT_WFD_MGR(manager);
4007         manager = wfd_get_manager();
4008
4009         activate_handler(NULL, NULL);
4010         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4011
4012         MethodInjector *group_create_method = new MethodInjector;
4013         create_group_handler(group_create_method->CreateGroup(), NULL);
4014
4015         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
4016         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
4017
4018         wfd_event_prov_disc_req((wfd_oem_event_s*)event->ProvReqDisplayPin(false));
4019
4020         get_local_wps_mode_handler(NULL, NULL);
4021         get_wps_pin_handler(NULL, NULL);
4022
4023         MethodInjector *accept_connect_method = new MethodInjector;
4024         accept_connection_handler(accept_connect_method->AcceptConnect(), NULL);
4025         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTING);
4026
4027         wfd_event_sta_connected((wfd_oem_event_s*)event->PeerJoined());
4028         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
4029
4030         wfd_event_sta_disconnected((wfd_oem_event_s*)event->PeerDisconnected());
4031         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4032         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4033
4034         deactivate_handler(NULL, NULL);
4035         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4036
4037         wfd_manager_unload();
4038
4039         delete event;
4040         delete group_create_method;
4041         delete accept_connect_method;
4042 }
4043
4044 TEST(wfd_mgr_connect_srv, srv_discovery_Positive)
4045 {
4046         wfd_manager_s * manager = NULL;
4047
4048         INIT_WFD_MGR(manager);
4049         manager = wfd_get_manager();
4050
4051         activate_handler(NULL, NULL);
4052         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4053
4054         manager->is_service_discovery_supported = true;
4055
4056         MethodInjector *srv_start = new MethodInjector;
4057         srv_start_discovery_handler(srv_start->SrvStartDiscovery(), NULL);
4058
4059         MethodInjector *srv_stop = new MethodInjector;
4060         srv_stop_discovery_handler(srv_start->SrvStopDiscovery(), NULL);
4061
4062         deactivate_handler(NULL, NULL);
4063         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4064
4065         wfd_manager_unload();
4066
4067         delete srv_start;
4068         delete srv_stop;
4069 }
4070
4071 TEST(wfd_mgr_connect_srv, srv_start_discovery_handler_Negative1)
4072 {
4073
4074         MethodInjector *srv_start = new MethodInjector;
4075         srv_start_discovery_handler(srv_start->SrvStartDiscovery(), NULL);
4076
4077         delete srv_start;
4078 }
4079
4080 TEST(wfd_mgr_connect_srv, srv_start_discovery_handler_Negative2)
4081 {
4082         wfd_manager_s * manager = NULL;
4083
4084         INIT_WFD_MGR(manager);
4085         manager = wfd_get_manager();
4086
4087         MethodInjector *srv_start = new MethodInjector;
4088         srv_start_discovery_handler(srv_start->SrvStartDiscovery(), NULL);
4089
4090         wfd_manager_unload();
4091
4092         delete srv_start;
4093 }
4094
4095 TEST(wfd_mgr_connect_srv, srv_start_discovery_handler_Negative3)
4096 {
4097         wfd_manager_s * manager = NULL;
4098
4099         INIT_WFD_MGR(manager);
4100         manager = wfd_get_manager();
4101         manager->is_service_discovery_supported = true;
4102
4103         MethodInjector *srv_start = new MethodInjector;
4104         srv_start_discovery_handler(srv_start->SrvStartDiscovery(), NULL);
4105
4106         wfd_manager_unload();
4107
4108         delete srv_start;
4109 }
4110
4111 TEST(wfd_mgr_connect_srv, srv_stop_discovery_handler_Negative1)
4112 {
4113
4114         MethodInjector *srv_stop = new MethodInjector;
4115         srv_stop_discovery_handler(srv_stop->SrvStopDiscovery(), NULL);
4116
4117         delete srv_stop;
4118 }
4119
4120 TEST(wfd_mgr_connect_srv, srv_stop_discovery_handler_Negative2)
4121 {
4122         wfd_manager_s * manager = NULL;
4123
4124         INIT_WFD_MGR(manager);
4125         manager = wfd_get_manager();
4126
4127         MethodInjector *srv_stop = new MethodInjector;
4128         srv_stop_discovery_handler(srv_stop->SrvStopDiscovery(), NULL);
4129
4130         wfd_manager_unload();
4131
4132         delete srv_stop;
4133 }
4134
4135 TEST(wfd_mgr_connect_srv, srv_stop_discovery_handler_Negative3)
4136 {
4137         wfd_manager_s * manager = NULL;
4138
4139         INIT_WFD_MGR(manager);
4140         manager = wfd_get_manager();
4141         manager->is_service_discovery_supported = true;
4142
4143         MethodInjector *srv_stop = new MethodInjector;
4144         srv_stop_discovery_handler(srv_stop->SrvStopDiscovery(), NULL);
4145
4146         wfd_manager_unload();
4147
4148         delete srv_stop;
4149 }
4150
4151 TEST(wfd_mgr_connect_srv, srv_register_deregister_Positive1)
4152 {
4153         wfd_manager_s * manager = NULL;
4154
4155         INIT_WFD_MGR(manager);
4156         manager = wfd_get_manager();
4157
4158         activate_handler(NULL, NULL);
4159         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4160
4161         manager->is_service_discovery_supported = true;
4162
4163         MethodInjector *srv_register = new MethodInjector;
4164         srv_register_handler(srv_register->SrvRegister(), NULL);
4165
4166         MethodInjector *srv_deregister = new MethodInjector;
4167         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4168
4169         deactivate_handler(NULL, NULL);
4170         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4171
4172         wfd_manager_unload();
4173
4174         delete srv_register;
4175         delete srv_deregister;
4176 }
4177
4178 TEST(wfd_mgr_connect_srv, srv_register_deregister_Positive2)
4179 {
4180         wfd_manager_s * manager = NULL;
4181
4182         INIT_WFD_MGR(manager);
4183         manager = wfd_get_manager();
4184
4185         activate_handler(NULL, NULL);
4186         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4187
4188         manager->is_service_discovery_supported = true;
4189
4190         MethodInjector *srv_register = new MethodInjector;
4191         srv_register_handler(srv_register->SrvRegisterBonjourPtr(), NULL);
4192
4193         MethodInjector *srv_deregister = new MethodInjector;
4194         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4195
4196         deactivate_handler(NULL, NULL);
4197         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4198
4199         wfd_manager_unload();
4200
4201         delete srv_register;
4202         delete srv_deregister;
4203 }
4204
4205 TEST(wfd_mgr_connect_srv, srv_register_deregister_Positive3)
4206 {
4207         wfd_manager_s * manager = NULL;
4208
4209         INIT_WFD_MGR(manager);
4210         manager = wfd_get_manager();
4211
4212         activate_handler(NULL, NULL);
4213         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4214
4215         manager->is_service_discovery_supported = true;
4216
4217         MethodInjector *srv_register = new MethodInjector;
4218         srv_register_handler(srv_register->SrvRegisterBonjourTxt(), NULL);
4219
4220         MethodInjector *srv_deregister = new MethodInjector;
4221         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4222
4223         deactivate_handler(NULL, NULL);
4224         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4225
4226         wfd_manager_unload();
4227
4228         delete srv_register;
4229         delete srv_deregister;
4230 }
4231
4232 TEST(wfd_mgr_connect_srv, srv_register_deregister_Positive4)
4233 {
4234         wfd_manager_s * manager = NULL;
4235
4236         INIT_WFD_MGR(manager);
4237         manager = wfd_get_manager();
4238
4239         activate_handler(NULL, NULL);
4240         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4241
4242         manager->is_service_discovery_supported = true;
4243
4244         MethodInjector *srv_register = new MethodInjector;
4245         srv_register_handler(srv_register->SrvRegister(0xff, "Vendor|Specific"), NULL);
4246
4247         MethodInjector *srv_deregister = new MethodInjector;
4248         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4249
4250         deactivate_handler(NULL, NULL);
4251         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4252
4253         wfd_manager_unload();
4254
4255         delete srv_register;
4256         delete srv_deregister;
4257 }
4258
4259 TEST(wfd_mgr_connect_srv, srv_register_handler_Negative1)
4260 {
4261
4262         MethodInjector *srv_register = new MethodInjector;
4263         srv_register_handler(srv_register->SrvRegister(), NULL);
4264
4265         delete srv_register;
4266 }
4267
4268 TEST(wfd_mgr_connect_srv, srv_register_handler_Negative2)
4269 {
4270         wfd_manager_s * manager = NULL;
4271         GList *services = NULL;
4272
4273         INIT_WFD_MGR(manager);
4274         manager = wfd_get_manager();
4275
4276         MethodInjector *srv_register = new MethodInjector;
4277         srv_register_handler(srv_register->SrvRegister(), NULL);
4278         ASSERT_EQ(services, manager->local->services);
4279
4280         wfd_manager_unload();
4281
4282         delete srv_register;
4283 }
4284
4285 TEST(wfd_mgr_connect_srv, srv_register_handler_Negative3)
4286 {
4287         wfd_manager_s * manager = NULL;
4288         GList *services = NULL;
4289
4290         INIT_WFD_MGR(manager);
4291         manager = wfd_get_manager();
4292         manager->is_service_discovery_supported = true;
4293
4294         MethodInjector *srv_register = new MethodInjector;
4295         srv_register_handler(srv_register->SrvRegister(), NULL);
4296         ASSERT_EQ(services, manager->local->services);
4297
4298         wfd_manager_unload();
4299
4300         delete srv_register;
4301 }
4302
4303 TEST(wfd_mgr_connect_srv, srv_register_handler_Negative4)
4304 {
4305         wfd_manager_s * manager = NULL;
4306         GList *services = NULL;
4307
4308         INIT_WFD_MGR(manager);
4309         manager = wfd_get_manager();
4310         manager->is_service_discovery_supported = true;
4311
4312         MethodInjector *srv_register = new MethodInjector;
4313         srv_register_handler(srv_register->SrvRegister(4, "Wrong|Type"), NULL);
4314         ASSERT_EQ(services, manager->local->services);
4315
4316         wfd_manager_unload();
4317
4318         delete srv_register;
4319 }
4320
4321 TEST(wfd_mgr_connect_srv, srv_register_handler_Negative5)
4322 {
4323         wfd_manager_s * manager = NULL;
4324         GList *services = NULL;
4325
4326         INIT_WFD_MGR(manager);
4327         manager = wfd_get_manager();
4328         manager->is_service_discovery_supported = true;
4329
4330         MethodInjector *srv_register = new MethodInjector;
4331         srv_register_handler(srv_register->SrvRegister(10, "Invalid|ServiceType"), NULL);
4332         ASSERT_EQ(services, manager->local->services);
4333
4334         wfd_manager_unload();
4335
4336         delete srv_register;
4337 }
4338
4339 TEST(wfd_mgr_connect_srv, srv_register_handler_Negative6)
4340 {
4341         wfd_manager_s * manager = NULL;
4342         GList *services = NULL;
4343
4344         INIT_WFD_MGR(manager);
4345         manager = wfd_get_manager();
4346         manager->is_service_discovery_supported = true;
4347
4348         MethodInjector *srv_register = new MethodInjector;
4349         srv_register_handler(srv_register->SrvRegister(2, "InvalidServiceStr"), NULL);
4350         ASSERT_EQ(services, manager->local->services);
4351
4352         wfd_manager_unload();
4353
4354         delete srv_register;
4355 }
4356
4357 TEST(wfd_mgr_connect_srv, srv_deregister_handler_Negative1)
4358 {
4359
4360         MethodInjector *srv_deregister = new MethodInjector;
4361         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4362
4363         delete srv_deregister;
4364 }
4365
4366 TEST(wfd_mgr_connect_srv, srv_deregister_handler_Negative2)
4367 {
4368         wfd_manager_s * manager = NULL;
4369
4370         INIT_WFD_MGR(manager);
4371         manager = wfd_get_manager();
4372
4373         MethodInjector *srv_deregister = new MethodInjector;
4374         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4375
4376         wfd_manager_unload();
4377
4378         delete srv_deregister;
4379 }
4380
4381 TEST(wfd_mgr_connect_srv, srv_deregister_handler_Negative3)
4382 {
4383         wfd_manager_s * manager = NULL;
4384
4385         INIT_WFD_MGR(manager);
4386         manager = wfd_get_manager();
4387         manager->is_service_discovery_supported = true;
4388
4389         MethodInjector *srv_deregister = new MethodInjector;
4390         srv_deregister_handler(srv_deregister->SrvDeregister(), NULL);
4391
4392         wfd_manager_unload();
4393
4394         delete srv_deregister;
4395 }
4396
4397
4398 TEST(wfd_mgr_connect_srv, wfd_event_serv_disc_resp_Positive)
4399 {
4400         EventInjector *event = new EventInjector;
4401         wfd_manager_s * manager = NULL;
4402
4403         INIT_WFD_MGR(manager);
4404         manager = wfd_get_manager();
4405
4406         activate_handler(NULL, NULL);
4407         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4408
4409         manager->is_service_discovery_supported = true;
4410
4411         wfd_event_peer_found((wfd_oem_event_s *)event->PeerFound());
4412         wfd_event_serv_disc_resp((wfd_oem_event_s*)event->ServDiscResp());
4413
4414         deactivate_handler(NULL, NULL);
4415         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4416
4417         wfd_manager_unload();
4418
4419         delete event;
4420 }
4421
4422 TEST(wfd_mgr_asp, asp_advertise_Positive1)
4423 {
4424         wfd_manager_s * manager = NULL;
4425
4426         INIT_WFD_MGR(manager);
4427         manager = wfd_get_manager();
4428
4429         activate_handler(NULL, NULL);
4430         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4431
4432         manager->is_asp_supported = true;
4433
4434         MethodInjector *advertse_start = new MethodInjector;
4435         advertise_service_handler(advertse_start->AspAdvertise(), NULL);
4436         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
4437         ASSERT_EQ(WFD_SCAN_MODE_PASSIVE, manager->scan_mode);
4438
4439         MethodInjector *advertise_cancel = new MethodInjector;
4440         cancel_advertise_service_handler(advertise_cancel->AspAdvertiseCancel(), NULL);
4441
4442         deactivate_handler(NULL, NULL);
4443         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4444
4445         wfd_manager_unload();
4446
4447         delete advertse_start;
4448         delete advertise_cancel;
4449 }
4450
4451 TEST(wfd_mgr_asp, asp_advertise_Positive2)
4452 {
4453         EventInjector *event = new EventInjector;
4454         wfd_manager_s * manager = NULL;
4455
4456         INIT_WFD_MGR(manager);
4457         manager = wfd_get_manager();
4458
4459         activate_handler(NULL, NULL);
4460         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4461
4462         MethodInjector *group_create_method = new MethodInjector;
4463         create_group_handler(group_create_method->CreateGroup(), NULL);
4464
4465         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGO());
4466         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_GROUP_OWNER);
4467
4468         manager->is_asp_supported = true;
4469
4470         MethodInjector *advertse_start = new MethodInjector;
4471         advertise_service_handler(advertse_start->AspAdvertise(), NULL);
4472
4473         MethodInjector *advertise_cancel = new MethodInjector;
4474         cancel_advertise_service_handler(advertise_cancel->AspAdvertiseCancel(), NULL);
4475
4476         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4477         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4478
4479         deactivate_handler(NULL, NULL);
4480         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4481
4482         wfd_manager_unload();
4483
4484         delete advertse_start;
4485         delete advertise_cancel;
4486         delete group_create_method;
4487         delete event;
4488 }
4489
4490 TEST(wfd_mgr_asp, advertise_service_handler_Negative1)
4491 {
4492
4493         MethodInjector *advertse_start = new MethodInjector;
4494         advertise_service_handler(advertse_start->AspAdvertise(), NULL);
4495
4496         delete advertse_start;
4497 }
4498
4499 TEST(wfd_mgr_asp, advertise_service_handler_Negative2)
4500 {
4501         wfd_manager_s * manager = NULL;
4502
4503         INIT_WFD_MGR(manager);
4504         manager = wfd_get_manager();
4505
4506         MethodInjector *advertse_start = new MethodInjector;
4507         advertise_service_handler(advertse_start->AspAdvertise(), NULL);
4508
4509         wfd_manager_unload();
4510
4511         delete advertse_start;
4512 }
4513
4514 TEST(wfd_mgr_asp, advertise_service_handler_Negative3)
4515 {
4516         wfd_manager_s * manager = NULL;
4517
4518         INIT_WFD_MGR(manager);
4519         manager = wfd_get_manager();
4520
4521         manager->is_asp_supported = true;
4522
4523         MethodInjector *advertse_start = new MethodInjector;
4524         advertise_service_handler(advertse_start->AspAdvertise(), NULL);
4525
4526         wfd_manager_unload();
4527
4528         delete advertse_start;
4529 }
4530
4531 TEST(wfd_mgr_asp, cancel_advertise_service_handler_Negative1)
4532 {
4533
4534         MethodInjector *advertise_cancel = new MethodInjector;
4535         cancel_advertise_service_handler(advertise_cancel->AspAdvertiseCancel(), NULL);
4536
4537         delete advertise_cancel;
4538 }
4539
4540 TEST(wfd_mgr_asp, cancel_advertise_service_handler_Negative2)
4541 {
4542         wfd_manager_s * manager = NULL;
4543
4544         INIT_WFD_MGR(manager);
4545         manager = wfd_get_manager();
4546
4547         MethodInjector *advertise_cancel = new MethodInjector;
4548         cancel_advertise_service_handler(advertise_cancel->AspAdvertiseCancel(), NULL);
4549
4550         wfd_manager_unload();
4551
4552         delete advertise_cancel;
4553 }
4554
4555 TEST(wfd_mgr_asp, cancel_advertise_service_handler_Negative3)
4556 {
4557         wfd_manager_s * manager = NULL;
4558
4559         INIT_WFD_MGR(manager);
4560         manager = wfd_get_manager();
4561
4562         manager->is_asp_supported = true;
4563
4564         MethodInjector *advertise_cancel = new MethodInjector;
4565         cancel_advertise_service_handler(advertise_cancel->AspAdvertiseCancel(), NULL);
4566
4567         wfd_manager_unload();
4568
4569         delete advertise_cancel;
4570 }
4571
4572 TEST(wfd_mgr_asp, asp_seek_service_Positive)
4573 {
4574         wfd_manager_s * manager = NULL;
4575
4576         INIT_WFD_MGR(manager);
4577         manager = wfd_get_manager();
4578
4579         activate_handler(NULL, NULL);
4580         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4581
4582         manager->is_asp_supported = true;
4583
4584         MethodInjector *asp_seek = new MethodInjector;
4585         seek_service_handler(asp_seek->AspSeek(), NULL);
4586         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
4587         ASSERT_EQ(WFD_SCAN_MODE_ACTIVE, manager->scan_mode);
4588
4589         MethodInjector *asp_seek_cancel = new MethodInjector;
4590         cancel_seek_service_handler(asp_seek_cancel->AspSeekCancel(), NULL);
4591
4592         deactivate_handler(NULL, NULL);
4593         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4594
4595         wfd_manager_unload();
4596
4597         delete asp_seek;
4598         delete asp_seek_cancel;
4599 }
4600
4601 TEST(wfd_mgr_asp, seek_service_handler_Negative1)
4602 {
4603
4604         MethodInjector *asp_seek = new MethodInjector;
4605         seek_service_handler(asp_seek->AspSeek(), NULL);
4606
4607         delete asp_seek;
4608 }
4609
4610 TEST(wfd_mgr_asp, seek_service_handler_Negative2)
4611 {
4612         wfd_manager_s * manager = NULL;
4613
4614         INIT_WFD_MGR(manager);
4615         manager = wfd_get_manager();
4616
4617         MethodInjector *asp_seek = new MethodInjector;
4618         seek_service_handler(asp_seek->AspSeek(), NULL);
4619
4620         wfd_manager_unload();
4621
4622         delete asp_seek;
4623 }
4624
4625 TEST(wfd_mgr_asp, seek_service_handler_Negative3)
4626 {
4627         wfd_manager_s * manager = NULL;
4628
4629         INIT_WFD_MGR(manager);
4630         manager = wfd_get_manager();
4631
4632         manager->is_asp_supported = true;
4633
4634         MethodInjector *asp_seek = new MethodInjector;
4635         seek_service_handler(asp_seek->AspSeek(), NULL);
4636
4637         wfd_manager_unload();
4638
4639         delete asp_seek;
4640 }
4641
4642 TEST(wfd_mgr_asp, cancel_seek_service_handler_Negative1)
4643 {
4644
4645         MethodInjector *asp_seek_cancel = new MethodInjector;
4646         cancel_seek_service_handler(asp_seek_cancel->AspSeekCancel(), NULL);
4647
4648         delete asp_seek_cancel;
4649 }
4650
4651 TEST(wfd_mgr_asp, cancel_seek_service_handler_Negative2)
4652 {
4653         wfd_manager_s * manager = NULL;
4654
4655         INIT_WFD_MGR(manager);
4656         manager = wfd_get_manager();
4657
4658         MethodInjector *asp_seek_cancel = new MethodInjector;
4659         cancel_seek_service_handler(asp_seek_cancel->AspSeekCancel(), NULL);
4660
4661         wfd_manager_unload();
4662
4663         delete asp_seek_cancel;
4664 }
4665
4666 TEST(wfd_mgr_asp, cancel_seek_service_handler_Negative3)
4667 {
4668         wfd_manager_s * manager = NULL;
4669
4670         INIT_WFD_MGR(manager);
4671         manager = wfd_get_manager();
4672
4673         manager->is_asp_supported = true;
4674
4675         MethodInjector *asp_seek_cancel = new MethodInjector;
4676         cancel_seek_service_handler(asp_seek_cancel->AspSeekCancel(), NULL);
4677
4678         wfd_manager_unload();
4679
4680         delete asp_seek_cancel;
4681 }
4682
4683 TEST(wfd_mgr_asp, asp_peer_found_Positive)
4684 {
4685         wfd_manager_s * manager = NULL;
4686         EventInjector *event = new EventInjector;
4687
4688         INIT_WFD_MGR(manager);
4689         manager = wfd_get_manager();
4690
4691         activate_handler(NULL, NULL);
4692         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4693
4694         manager->is_asp_supported = true;
4695
4696         MethodInjector *asp_seek = new MethodInjector;
4697         seek_service_handler(asp_seek->AspSeek(), NULL);
4698         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
4699         ASSERT_EQ(WFD_SCAN_MODE_ACTIVE, manager->scan_mode);
4700
4701         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4702
4703         MethodInjector *asp_seek_cancel = new MethodInjector;
4704         cancel_seek_service_handler(asp_seek_cancel->AspSeekCancel(), NULL);
4705
4706         deactivate_handler(NULL, NULL);
4707         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4708
4709         wfd_manager_unload();
4710
4711         delete event;
4712         delete asp_seek;
4713         delete asp_seek_cancel;
4714 }
4715
4716 TEST(wfd_mgr_asp, asp_service_found_Positive)
4717 {
4718         wfd_manager_s * manager = NULL;
4719         EventInjector *event = new EventInjector;
4720
4721         INIT_WFD_MGR(manager);
4722         manager = wfd_get_manager();
4723
4724         activate_handler(NULL, NULL);
4725         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4726
4727         manager->is_asp_supported = true;
4728
4729         MethodInjector *asp_seek = new MethodInjector;
4730         seek_service_handler(asp_seek->AspSeek(), NULL);
4731         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DISCOVERING);
4732         ASSERT_EQ(WFD_SCAN_MODE_ACTIVE, manager->scan_mode);
4733
4734         wfd_event_asp_serv_resp((wfd_oem_event_s *)event->AspServiceFound());
4735
4736         MethodInjector *asp_seek_cancel = new MethodInjector;
4737         cancel_seek_service_handler(asp_seek_cancel->AspSeekCancel(), NULL);
4738
4739         deactivate_handler(NULL, NULL);
4740         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4741
4742         wfd_manager_unload();
4743
4744         delete asp_seek;
4745         delete asp_seek_cancel;
4746         delete event;
4747 }
4748
4749 TEST(wfd_mgr_asp, asp_connect_session_Positive1)
4750 {
4751         wfd_manager_s * manager = NULL;
4752         EventInjector *event = new EventInjector;
4753
4754         INIT_WFD_MGR(manager);
4755         manager = wfd_get_manager();
4756
4757         activate_handler(NULL, NULL);
4758         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4759
4760         manager->is_asp_supported = true;
4761
4762         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4763         wfd_event_asp_prov_done((wfd_oem_event_s *)event->AspProvDone
4764                         (WFD_OEM_SC_SUCCESS, WFD_WPS_MODE_P2PS, WFD_OEM_ASP_SESSION_ROLE_NEW, 0, 0));
4765
4766         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
4767         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
4768         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
4769
4770         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4771         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4772
4773         deactivate_handler(NULL, NULL);
4774         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4775
4776         wfd_manager_unload();
4777
4778         delete event;
4779 }
4780
4781 TEST(wfd_mgr_asp, asp_connect_session_Positive2)
4782 {
4783         wfd_manager_s * manager = NULL;
4784         EventInjector *event = new EventInjector;
4785
4786         INIT_WFD_MGR(manager);
4787         manager = wfd_get_manager();
4788
4789         activate_handler(NULL, NULL);
4790         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4791
4792         manager->is_asp_supported = true;
4793
4794         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4795
4796         MethodInjector *asp_connect = new MethodInjector;
4797         connect_sessoin_handler(asp_connect->AspSessionConnect
4798                         (asp_connect->local_mac_str,
4799                                         WFD_OEM_ASP_WPS_TYPE_NONE,
4800                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
4801
4802         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
4803                         (WFD_OEM_SC_SUCCESS, WFD_WPS_MODE_P2PS, WFD_OEM_ASP_SESSION_ROLE_NEW, 0, 0));
4804
4805         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
4806         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
4807         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
4808
4809         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4810         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4811
4812         deactivate_handler(NULL, NULL);
4813         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4814
4815         wfd_manager_unload();
4816
4817         delete asp_connect;
4818         delete event;
4819 }
4820
4821 TEST(wfd_mgr_asp, asp_connect_session_Positive3)
4822 {
4823         wfd_manager_s * manager = NULL;
4824         EventInjector *event = new EventInjector;
4825
4826         INIT_WFD_MGR(manager);
4827         manager = wfd_get_manager();
4828
4829         activate_handler(NULL, NULL);
4830         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4831
4832         manager->is_asp_supported = true;
4833
4834         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4835
4836         MethodInjector *asp_connect = new MethodInjector;
4837         connect_sessoin_handler(asp_connect->AspSessionConnect
4838                         (asp_connect->local_mac_str,
4839                                         WFD_OEM_ASP_WPS_TYPE_NONE,
4840                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
4841
4842         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->AspProvFail(WFD_OEM_SC_FAIL_INVALID_PARAMS));
4843         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
4844                         (WFD_OEM_SC_SUCCESS_ACCEPTED_BY_USER, WFD_WPS_MODE_P2PS,
4845                                         WFD_OEM_ASP_SESSION_ROLE_NEW, 0, 0));
4846
4847         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
4848         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
4849         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
4850
4851         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4852         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4853
4854         deactivate_handler(NULL, NULL);
4855         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4856
4857         wfd_manager_unload();
4858
4859         delete asp_connect;
4860         delete event;
4861 }
4862
4863
4864 TEST(wfd_mgr_asp, asp_connect_session_Positive4)
4865 {
4866         wfd_manager_s * manager = NULL;
4867         EventInjector *event = new EventInjector;
4868
4869         INIT_WFD_MGR(manager);
4870         manager = wfd_get_manager();
4871
4872         activate_handler(NULL, NULL);
4873         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4874
4875         manager->is_asp_supported = true;
4876
4877         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4878
4879         MethodInjector *asp_connect = new MethodInjector;
4880         connect_sessoin_handler(asp_connect->AspSessionConnect
4881                         (asp_connect->local_mac_str,
4882                                         WFD_OEM_ASP_WPS_TYPE_NONE,
4883                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
4884
4885         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->AspProvFail(WFD_OEM_SC_FAIL_INVALID_PARAMS));
4886         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
4887                         (WFD_OEM_SC_SUCCESS_ACCEPTED_BY_USER, 0, 0, 1, 0));
4888
4889         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
4890         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
4891
4892         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4893         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4894
4895         deactivate_handler(NULL, NULL);
4896         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4897
4898         wfd_manager_unload();
4899
4900         delete asp_connect;
4901         delete event;
4902 }
4903
4904
4905 TEST(wfd_mgr_asp, asp_connect_session_Positive5)
4906 {
4907         wfd_manager_s * manager = NULL;
4908         EventInjector *event = new EventInjector;
4909
4910         INIT_WFD_MGR(manager);
4911         manager = wfd_get_manager();
4912
4913         activate_handler(NULL, NULL);
4914         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4915
4916         manager->is_asp_supported = true;
4917
4918         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4919
4920         wfd_event_asp_prov_start((wfd_oem_event_s*)event->AspProvStart
4921                         (WFD_WPS_MODE_P2PS, WFD_OEM_ASP_SESSION_ROLE_NEW));
4922
4923         MethodInjector *asp_confirm = new MethodInjector;
4924         confirm_sessoin_handler(asp_confirm->AspSessionConfirm
4925                         (asp_confirm->local_mac_str,
4926                                         1, NULL), NULL);
4927
4928         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
4929                         (WFD_OEM_SC_SUCCESS_ACCEPTED_BY_USER, WFD_WPS_MODE_P2PS,
4930                                         WFD_OEM_ASP_SESSION_ROLE_NEW, 0, 0));
4931
4932         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
4933         wfd_event_group_created((wfd_oem_event_s*)event->GroupStartedGC());
4934         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_CONNECTED);
4935
4936         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
4937         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4938
4939         deactivate_handler(NULL, NULL);
4940         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4941
4942         wfd_manager_unload();
4943
4944         delete asp_confirm;
4945         delete event;
4946 }
4947
4948 TEST(wfd_mgr_asp, asp_connect_session_Negative1)
4949 {
4950         wfd_manager_s * manager = NULL;
4951         EventInjector *event = new EventInjector;
4952
4953         INIT_WFD_MGR(manager);
4954         manager = wfd_get_manager();
4955
4956         activate_handler(NULL, NULL);
4957         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4958
4959         manager->is_asp_supported = true;
4960
4961         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4962
4963         MethodInjector *asp_connect = new MethodInjector;
4964         connect_sessoin_handler(asp_connect->AspSessionConnect
4965                         (asp_connect->local_mac_str,
4966                                         WFD_OEM_ASP_WPS_TYPE_NONE,
4967                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
4968
4969         wfd_event_prov_disc_fail((wfd_oem_event_s*)event->AspProvFail(WFD_OEM_SC_FAIL_INCOMPATIBLE_PROV_METHOD));
4970         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4971
4972         deactivate_handler(NULL, NULL);
4973         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
4974
4975         wfd_manager_unload();
4976
4977         delete asp_connect;
4978         delete event;
4979 }
4980
4981 TEST(wfd_mgr_asp, asp_connect_session_Negative2)
4982 {
4983         wfd_manager_s * manager = NULL;
4984         EventInjector *event = new EventInjector;
4985
4986         INIT_WFD_MGR(manager);
4987         manager = wfd_get_manager();
4988
4989         activate_handler(NULL, NULL);
4990         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
4991
4992         manager->is_asp_supported = true;
4993
4994         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
4995
4996         MethodInjector *asp_connect = new MethodInjector;
4997         connect_sessoin_handler(asp_connect->AspSessionConnect
4998                         (asp_connect->local_mac_str,
4999                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5000                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5001
5002         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5003                         (WFD_OEM_SC_FAIL_REJECTED_BY_USER, 0, 0, 0, 0));
5004         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5005
5006         deactivate_handler(NULL, NULL);
5007         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5008
5009         wfd_manager_unload();
5010
5011         delete asp_connect;
5012         delete event;
5013 }
5014
5015 TEST(wfd_mgr_asp, asp_connect_session_Negative3)
5016 {
5017         wfd_manager_s * manager = NULL;
5018         EventInjector *event = new EventInjector;
5019
5020         INIT_WFD_MGR(manager);
5021         manager = wfd_get_manager();
5022
5023         activate_handler(NULL, NULL);
5024         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5025
5026         manager->is_asp_supported = true;
5027
5028         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
5029
5030         MethodInjector *asp_connect = new MethodInjector;
5031         connect_sessoin_handler(asp_connect->AspSessionConnect
5032                         (asp_connect->local_mac_str,
5033                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5034                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5035
5036         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5037                         (WFD_OEM_SC_SUCCESS,
5038                                         WFD_WPS_MODE_DISPLAY,
5039                                         WFD_OEM_ASP_SESSION_ROLE_NEW,
5040                                         1, 0));
5041         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5042
5043         deactivate_handler(NULL, NULL);
5044         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5045
5046         wfd_manager_unload();
5047
5048         delete asp_connect;
5049         delete event;
5050 }
5051
5052 TEST(wfd_mgr_asp, asp_connect_session_Negative4)
5053 {
5054         wfd_manager_s * manager = NULL;
5055         EventInjector *event = new EventInjector;
5056
5057         INIT_WFD_MGR(manager);
5058         manager = wfd_get_manager();
5059
5060         activate_handler(NULL, NULL);
5061         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5062
5063         manager->is_asp_supported = true;
5064
5065         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
5066
5067         MethodInjector *asp_connect = new MethodInjector;
5068         connect_sessoin_handler(asp_connect->AspSessionConnect
5069                         (asp_connect->local_mac_str,
5070                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5071                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5072
5073         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5074                         (WFD_OEM_SC_SUCCESS, 0, 0, 0, 0));
5075         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5076
5077         deactivate_handler(NULL, NULL);
5078         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5079
5080         wfd_manager_unload();
5081
5082         delete asp_connect;
5083         delete event;
5084 }
5085 TEST(wfd_mgr_asp, asp_connect_session_Negative5)
5086 {
5087         wfd_manager_s * manager = NULL;
5088         EventInjector *event = new EventInjector;
5089
5090         INIT_WFD_MGR(manager);
5091         manager = wfd_get_manager();
5092
5093         activate_handler(NULL, NULL);
5094         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5095
5096         manager->is_asp_supported = true;
5097
5098         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
5099
5100         MethodInjector *asp_connect = new MethodInjector;
5101         connect_sessoin_handler(asp_connect->AspSessionConnect
5102                         (asp_connect->local_mac_str,
5103                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5104                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5105
5106         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5107                         (WFD_OEM_SC_SUCCESS,
5108                                         WFD_WPS_MODE_P2PS,
5109                                         WFD_OEM_ASP_SESSION_ROLE_NEW,
5110                                         0, 0));
5111
5112         wfd_event_go_neg_fail((wfd_oem_event_s*)event->GoNegFailure());
5113         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5114
5115         deactivate_handler(NULL, NULL);
5116         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5117
5118         wfd_manager_unload();
5119
5120         delete asp_connect;
5121         delete event;
5122 }
5123
5124 TEST(wfd_mgr_asp, asp_connect_session_Negative6)
5125 {
5126         wfd_manager_s * manager = NULL;
5127         EventInjector *event = new EventInjector;
5128
5129         INIT_WFD_MGR(manager);
5130         manager = wfd_get_manager();
5131
5132         activate_handler(NULL, NULL);
5133         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5134
5135         manager->is_asp_supported = true;
5136
5137         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
5138
5139         MethodInjector *asp_connect = new MethodInjector;
5140         connect_sessoin_handler(asp_connect->AspSessionConnect
5141                         (asp_connect->local_mac_str,
5142                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5143                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5144
5145         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5146                         (WFD_OEM_SC_SUCCESS,
5147                                         WFD_WPS_MODE_P2PS,
5148                                         WFD_OEM_ASP_SESSION_ROLE_NEW,
5149                                         0, 0));
5150
5151         wfd_event_wps_fail((wfd_oem_event_s*)event->WpsFailed());
5152         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5153
5154         deactivate_handler(NULL, NULL);
5155         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5156
5157         wfd_manager_unload();
5158
5159         delete asp_connect;
5160         delete event;
5161 }
5162
5163 TEST(wfd_mgr_asp, asp_connect_session_Negative7)
5164 {
5165         wfd_manager_s * manager = NULL;
5166         EventInjector *event = new EventInjector;
5167
5168         INIT_WFD_MGR(manager);
5169         manager = wfd_get_manager();
5170
5171         activate_handler(NULL, NULL);
5172         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5173
5174         manager->is_asp_supported = true;
5175
5176         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
5177
5178         MethodInjector *asp_connect = new MethodInjector;
5179         connect_sessoin_handler(asp_connect->AspSessionConnect
5180                         (asp_connect->local_mac_str,
5181                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5182                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5183
5184         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5185                         (WFD_OEM_SC_SUCCESS,
5186                                         WFD_WPS_MODE_P2PS,
5187                                         WFD_OEM_ASP_SESSION_ROLE_NEW,
5188                                         0, 0));
5189
5190         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
5191         wfd_event_group_formation_failure((wfd_oem_event_s*)event->GroupFormationFailed());
5192         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5193
5194         deactivate_handler(NULL, NULL);
5195         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5196
5197         wfd_manager_unload();
5198
5199         delete asp_connect;
5200         delete event;
5201 }
5202
5203 TEST(wfd_mgr_asp, asp_connect_session_Negative8)
5204 {
5205         wfd_manager_s * manager = NULL;
5206         EventInjector *event = new EventInjector;
5207
5208         INIT_WFD_MGR(manager);
5209         manager = wfd_get_manager();
5210
5211         activate_handler(NULL, NULL);
5212         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5213
5214         manager->is_asp_supported = true;
5215
5216         wfd_event_peer_found((wfd_oem_event_s *)event->AspPeerFound());
5217
5218         MethodInjector *asp_connect = new MethodInjector;
5219         connect_sessoin_handler(asp_connect->AspSessionConnect
5220                         (asp_connect->local_mac_str,
5221                                         WFD_OEM_ASP_WPS_TYPE_NONE,
5222                                         WFD_OEM_ASP_SESSION_ROLE_NONE), NULL);
5223
5224         wfd_event_asp_prov_done((wfd_oem_event_s*)event->AspProvDone
5225                         (WFD_OEM_SC_SUCCESS,
5226                                         WFD_WPS_MODE_P2PS,
5227                                         WFD_OEM_ASP_SESSION_ROLE_NEW,
5228                                         0, 0));
5229
5230         wfd_event_go_neg_done((wfd_oem_event_s*)event->GoNegSuccessGc());
5231         wfd_event_group_destroyed((wfd_oem_event_s*)event->GroupFinished());
5232         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_ACTIVATED);
5233
5234         deactivate_handler(NULL, NULL);
5235         CHECK_WFD_MGR_STATE(manager, WIFI_DIRECT_STATE_DEACTIVATED);
5236
5237         wfd_manager_unload();
5238
5239         delete asp_connect;
5240         delete event;
5241 }
5242
5243 int main(int argc, char **argv)
5244 {
5245   InitGoogleTest(&argc, argv);
5246
5247   return RUN_ALL_TESTS();
5248 }
5249