tools/mgmt-tester.c

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2012  Intel Corporation. All rights reserved.
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <stdbool.h>
  30 #include <sys/ioctl.h>
  31
  32 #include <glib.h>
  33
  34 #include "lib/bluetooth.h"
  35 #include "lib/hci.h"
  36 #include "lib/hci_lib.h"
  37 #include "lib/mgmt.h"
  38
  39 #include "monitor/bt.h"
  40 #include "emulator/bthost.h"
  41 #include "emulator/hciemu.h"
  42
  43 #include "src/shared/util.h"
  44 #include "src/shared/tester.h"
  45 #include "src/shared/mgmt.h"
  46
  47 struct test_data {
  48         tester_data_func_t test_setup;
  49         const void *test_data;
  50         uint8_t expected_version;
  51         uint16_t expected_manufacturer;
  52         uint32_t expected_supported_settings;
  53         uint32_t initial_settings;
  54         struct mgmt *mgmt;
  55         struct mgmt *mgmt_alt;
  56         unsigned int mgmt_settings_id;
  57         unsigned int mgmt_alt_settings_id;
  58         unsigned int mgmt_alt_ev_id;
  59         unsigned int mgmt_discov_ev_id;
  60         uint8_t mgmt_version;
  61         uint16_t mgmt_revision;
  62         uint16_t mgmt_index;
  63         struct hciemu *hciemu;
  64         enum hciemu_type hciemu_type;
  65         int unmet_conditions;
  66 };
  67
  68 static void mgmt_debug(const char *str, void *user_data)
  69 {
  70         const char *prefix = user_data;
  71
  72         tester_print("%s%s", prefix, str);
  73 }
  74
  75 static void read_version_callback(uint8_t status, uint16_t length,
  76                                         const void *param, void *user_data)
  77 {
  78         struct test_data *data = tester_get_data();
  79         const struct mgmt_rp_read_version *rp = param;
  80
  81         tester_print("Read Version callback");
  82         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
  83
  84         if (status || !param) {
  85                 tester_pre_setup_failed();
  86                 return;
  87         }
  88
  89         data->mgmt_version = rp->version;
  90         data->mgmt_revision = btohs(rp->revision);
  91
  92         tester_print("  Version %u.%u",
  93                                 data->mgmt_version, data->mgmt_revision);
  94 }
  95
  96 static void read_commands_callback(uint8_t status, uint16_t length,
  97                                         const void *param, void *user_data)
  98 {
  99         tester_print("Read Commands callback");
 100         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 101
 102         if (status || !param) {
 103                 tester_pre_setup_failed();
 104                 return;
 105         }
 106 }
 107
 108 static void read_info_callback(uint8_t status, uint16_t length,
 109                                         const void *param, void *user_data)
 110 {
 111         struct test_data *data = tester_get_data();
 112         const struct mgmt_rp_read_info *rp = param;
 113         char addr[18];
 114         uint16_t manufacturer;
 115         uint32_t supported_settings, current_settings;
 116         struct bthost *bthost;
 117
 118         tester_print("Read Info callback");
 119         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 120
 121         if (status || !param) {
 122                 tester_pre_setup_failed();
 123                 return;
 124         }
 125
 126         ba2str(&rp->bdaddr, addr);
 127         manufacturer = btohs(rp->manufacturer);
 128         supported_settings = btohl(rp->supported_settings);
 129         current_settings = btohl(rp->current_settings);
 130
 131         tester_print("  Address: %s", addr);
 132         tester_print("  Version: 0x%02x", rp->version);
 133         tester_print("  Manufacturer: 0x%04x", manufacturer);
 134         tester_print("  Supported settings: 0x%08x", supported_settings);
 135         tester_print("  Current settings: 0x%08x", current_settings);
 136         tester_print("  Class: 0x%02x%02x%02x",
 137                         rp->dev_class[2], rp->dev_class[1], rp->dev_class[0]);
 138         tester_print("  Name: %s", rp->name);
 139         tester_print("  Short name: %s", rp->short_name);
 140
 141         if (strcmp(hciemu_get_address(data->hciemu), addr)) {
 142                 tester_pre_setup_failed();
 143                 return;
 144         }
 145
 146         if (rp->version != data->expected_version) {
 147                 tester_pre_setup_failed();
 148                 return;
 149         }
 150
 151         if (manufacturer != data->expected_manufacturer) {
 152                 tester_pre_setup_failed();
 153                 return;
 154         }
 155
 156         if (supported_settings != data->expected_supported_settings) {
 157                 tester_pre_setup_failed();
 158                 return;
 159         }
 160
 161         if (current_settings != data->initial_settings) {
 162                 tester_pre_setup_failed();
 163                 return;
 164         }
 165
 166         if (rp->dev_class[0] != 0x00 || rp->dev_class[1] != 0x00 ||
 167                                                 rp->dev_class[2] != 0x00) {
 168                 tester_pre_setup_failed();
 169                 return;
 170         }
 171
 172         bthost = hciemu_client_get_host(data->hciemu);
 173         bthost_notify_ready(bthost, tester_pre_setup_complete);
 174 }
 175
 176 static void index_added_callback(uint16_t index, uint16_t length,
 177                                         const void *param, void *user_data)
 178 {
 179         struct test_data *data = tester_get_data();
 180
 181         tester_print("Index Added callback");
 182         tester_print("  Index: 0x%04x", index);
 183
 184         data->mgmt_index = index;
 185
 186         mgmt_send(data->mgmt, MGMT_OP_READ_INFO, data->mgmt_index, 0, NULL,
 187                                         read_info_callback, NULL, NULL);
 188 }
 189
 190 static void index_removed_callback(uint16_t index, uint16_t length,
 191                                         const void *param, void *user_data)
 192 {
 193         struct test_data *data = tester_get_data();
 194
 195         tester_print("Index Removed callback");
 196         tester_print("  Index: 0x%04x", index);
 197
 198         if (index != data->mgmt_index)
 199                 return;
 200
 201         mgmt_unregister_index(data->mgmt, data->mgmt_index);
 202         mgmt_unregister_index(data->mgmt_alt, data->mgmt_index);
 203
 204         mgmt_unref(data->mgmt);
 205         data->mgmt = NULL;
 206
 207         mgmt_unref(data->mgmt_alt);
 208         data->mgmt_alt = NULL;
 209
 210         tester_post_teardown_complete();
 211 }
 212
 213 static void read_index_list_callback(uint8_t status, uint16_t length,
 214                                         const void *param, void *user_data)
 215 {
 216         struct test_data *data = tester_get_data();
 217
 218         tester_print("Read Index List callback");
 219         tester_print("  Status: %s (0x%02x)", mgmt_errstr(status), status);
 220
 221         if (status || !param) {
 222                 tester_pre_setup_failed();
 223                 return;
 224         }
 225
 226         mgmt_register(data->mgmt, MGMT_EV_INDEX_ADDED, MGMT_INDEX_NONE,
 227                                         index_added_callback, NULL, NULL);
 228
 229         mgmt_register(data->mgmt, MGMT_EV_INDEX_REMOVED, MGMT_INDEX_NONE,
 230                                         index_removed_callback, NULL, NULL);
 231
 232         data->hciemu = hciemu_new(data->hciemu_type);
 233         if (!data->hciemu) {
 234                 tester_warn("Failed to setup HCI emulation");
 235                 tester_pre_setup_failed();
 236         }
 237 }
 238
 239 static void test_pre_setup(const void *test_data)
 240 {
 241         struct test_data *data = tester_get_data();
 242
 243         data->mgmt = mgmt_new_default();
 244         if (!data->mgmt) {
 245                 tester_warn("Failed to setup management interface");
 246                 tester_pre_setup_failed();
 247                 return;
 248         }
 249
 250         data->mgmt_alt = mgmt_new_default();
 251         if (!data->mgmt_alt) {
 252                 tester_warn("Failed to setup alternate management interface");
 253                 tester_pre_setup_failed();
 254
 255                 mgmt_unref(data->mgmt);
 256                 data->mgmt = NULL;
 257                 return;
 258         }
 259
 260         if (tester_use_debug()) {
 261                 mgmt_set_debug(data->mgmt, mgmt_debug, "mgmt: ", NULL);
 262                 mgmt_set_debug(data->mgmt_alt, mgmt_debug, "mgmt-alt: ", NULL);
 263         }
 264
 265         mgmt_send(data->mgmt, MGMT_OP_READ_VERSION, MGMT_INDEX_NONE, 0, NULL,
 266                                         read_version_callback, NULL, NULL);
 267
 268         mgmt_send(data->mgmt, MGMT_OP_READ_COMMANDS, MGMT_INDEX_NONE, 0, NULL,
 269                                         read_commands_callback, NULL, NULL);
 270
 271         mgmt_send(data->mgmt, MGMT_OP_READ_INDEX_LIST, MGMT_INDEX_NONE, 0, NULL,
 272                                         read_index_list_callback, NULL, NULL);
 273 }
 274
 275 static void test_post_teardown(const void *test_data)
 276 {
 277         struct test_data *data = tester_get_data();
 278
 279         hciemu_unref(data->hciemu);
 280         data->hciemu = NULL;
 281 }
 282
 283 static void test_add_condition(struct test_data *data)
 284 {
 285         data->unmet_conditions++;
 286
 287         tester_print("Test condition added, total %d", data->unmet_conditions);
 288 }
 289
 290 static void test_condition_complete(struct test_data *data)
 291 {
 292         data->unmet_conditions--;
 293
 294         tester_print("Test condition complete, %d left",
 295                                                 data->unmet_conditions);
 296
 297         if (data->unmet_conditions > 0)
 298                 return;
 299
 300         tester_test_passed();
 301 }
 302
 303 #define test_bredrle_full(name, data, setup, func, timeout) \
 304         do { \
 305                 struct test_data *user; \
 306                 user = malloc(sizeof(struct test_data)); \
 307                 if (!user) \
 308                         break; \
 309                 user->hciemu_type = HCIEMU_TYPE_BREDRLE; \
 310                 user->test_setup = setup; \
 311                 user->test_data = data; \
 312                 user->expected_version = 0x08; \
 313                 user->expected_manufacturer = 0x003f; \
 314                 user->expected_supported_settings = 0x0000bfff; \
 315                 user->initial_settings = 0x00000080; \
 316                 user->unmet_conditions = 0; \
 317                 tester_add_full(name, data, \
 318                                 test_pre_setup, test_setup, func, NULL, \
 319                                 test_post_teardown, timeout, user, free); \
 320         } while (0)
 321
 322 #define test_bredrle(name, data, setup, func) \
 323         test_bredrle_full(name, data, setup, func, 2)
 324
 325 #define test_bredr20(name, data, setup, func) \
 326         do { \
 327                 struct test_data *user; \
 328                 user = malloc(sizeof(struct test_data)); \
 329                 if (!user) \
 330                         break; \
 331                 user->hciemu_type = HCIEMU_TYPE_LEGACY; \
 332                 user->test_setup = setup; \
 333                 user->test_data = data; \
 334                 user->expected_version = 0x03; \
 335                 user->expected_manufacturer = 0x003f; \
 336                 user->expected_supported_settings = 0x000010bf; \
 337                 user->initial_settings = 0x00000080; \
 338                 user->unmet_conditions = 0; \
 339                 tester_add_full(name, data, \
 340                                 test_pre_setup, test_setup, func, NULL, \
 341                                 test_post_teardown, 2, user, free); \
 342         } while (0)
 343
 344 #define test_bredr(name, data, setup, func) \
 345         do { \
 346                 struct test_data *user; \
 347                 user = malloc(sizeof(struct test_data)); \
 348                 if (!user) \
 349                         break; \
 350                 user->hciemu_type = HCIEMU_TYPE_BREDR; \
 351                 user->test_setup = setup; \
 352                 user->test_data = data; \
 353                 user->expected_version = 0x05; \
 354                 user->expected_manufacturer = 0x003f; \
 355                 user->expected_supported_settings = 0x000011ff; \
 356                 user->initial_settings = 0x00000080; \
 357                 user->unmet_conditions = 0; \
 358                 tester_add_full(name, data, \
 359                                 test_pre_setup, test_setup, func, NULL, \
 360                                 test_post_teardown, 2, user, free); \
 361         } while (0)
 362
 363 #define test_le(name, data, setup, func) \
 364         do { \
 365                 struct test_data *user; \
 366                 user = malloc(sizeof(struct test_data)); \
 367                 if (!user) \
 368                         break; \
 369                 user->hciemu_type = HCIEMU_TYPE_LE; \
 370                 user->test_setup = setup; \
 371                 user->test_data = data; \
 372                 user->expected_version = 0x08; \
 373                 user->expected_manufacturer = 0x003f; \
 374                 user->expected_supported_settings = 0x0000be1b; \
 375                 user->initial_settings = 0x00000200; \
 376                 user->unmet_conditions = 0; \
 377                 tester_add_full(name, data, \
 378                                 test_pre_setup, test_setup, func, NULL, \
 379                                 test_post_teardown, 2, user, free); \
 380         } while (0)
 381
 382 static void controller_setup(const void *test_data)
 383 {
 384         tester_test_passed();
 385 }
 386
 387 struct generic_data {
 388         const uint16_t *setup_settings;
 389         bool setup_nobredr;
 390         bool setup_limited_discov;
 391         uint16_t setup_expect_hci_command;
 392         const void *setup_expect_hci_param;
 393         uint8_t setup_expect_hci_len;
 394         uint16_t setup_send_opcode;
 395         const void *setup_send_param;
 396         uint16_t setup_send_len;
 397         bool send_index_none;
 398         uint16_t send_opcode;
 399         const void *send_param;
 400         uint16_t send_len;
 401         const void * (*send_func)(uint16_t *len);
 402         uint8_t expect_status;
 403         bool expect_ignore_param;
 404         const void *expect_param;
 405         uint16_t expect_len;
 406         const void * (*expect_func)(uint16_t *len);
 407         uint32_t expect_settings_set;
 408         uint32_t expect_settings_unset;
 409         uint16_t expect_alt_ev;
 410         const void *expect_alt_ev_param;
 411         bool (*verify_alt_ev_func)(const void *param, uint16_t length);
 412         uint16_t expect_alt_ev_len;
 413         uint16_t expect_hci_command;
 414         const void *expect_hci_param;
 415         uint8_t expect_hci_len;
 416         const void * (*expect_hci_func)(uint8_t *len);
 417         bool expect_pin;
 418         uint8_t pin_len;
 419         const void *pin;
 420         uint8_t client_pin_len;
 421         const void *client_pin;
 422         bool client_enable_ssp;
 423         uint8_t io_cap;
 424         uint8_t client_io_cap;
 425         uint8_t client_auth_req;
 426         bool reject_confirm;
 427         bool client_reject_confirm;
 428         bool just_works;
 429         bool client_enable_le;
 430         bool client_enable_sc;
 431         bool expect_sc_key;
 432         bool force_power_off;
 433         bool addr_type_avail;
 434         uint8_t addr_type;
 435         bool set_adv;
 436         const uint8_t *adv_data;
 437         uint8_t adv_data_len;
 438 };
 439
 440 static const char dummy_data[] = { 0x00 };
 441
 442 static const struct generic_data invalid_command_test = {
 443         .send_opcode = 0xffff,
 444         .expect_status = MGMT_STATUS_UNKNOWN_COMMAND,
 445 };
 446
 447 static const struct generic_data read_version_success_test = {
 448         .send_index_none = true,
 449         .send_opcode = MGMT_OP_READ_VERSION,
 450         .expect_status = MGMT_STATUS_SUCCESS,
 451         .expect_len = 3,
 452 };
 453
 454 static const struct generic_data read_version_invalid_param_test = {
 455         .send_index_none = true,
 456         .send_opcode = MGMT_OP_READ_VERSION,
 457         .send_param = dummy_data,
 458         .send_len = sizeof(dummy_data),
 459         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 460 };
 461
 462 static const struct generic_data read_version_invalid_index_test = {
 463         .send_opcode = MGMT_OP_READ_VERSION,
 464         .expect_status = MGMT_STATUS_INVALID_INDEX,
 465 };
 466
 467 static const struct generic_data read_commands_invalid_param_test = {
 468         .send_index_none = true,
 469         .send_opcode = MGMT_OP_READ_COMMANDS,
 470         .send_param = dummy_data,
 471         .send_len = sizeof(dummy_data),
 472         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 473 };
 474
 475 static const struct generic_data read_commands_invalid_index_test = {
 476         .send_opcode = MGMT_OP_READ_COMMANDS,
 477         .expect_status = MGMT_STATUS_INVALID_INDEX,
 478 };
 479
 480 static const struct generic_data read_index_list_invalid_param_test = {
 481         .send_index_none = true,
 482         .send_opcode = MGMT_OP_READ_INDEX_LIST,
 483         .send_param = dummy_data,
 484         .send_len = sizeof(dummy_data),
 485         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 486 };
 487
 488 static const struct generic_data read_index_list_invalid_index_test = {
 489         .send_opcode = MGMT_OP_READ_INDEX_LIST,
 490         .expect_status = MGMT_STATUS_INVALID_INDEX,
 491 };
 492
 493 static const struct generic_data read_info_invalid_param_test = {
 494         .send_opcode = MGMT_OP_READ_INFO,
 495         .send_param = dummy_data,
 496         .send_len = sizeof(dummy_data),
 497         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 498 };
 499
 500 static const struct generic_data read_info_invalid_index_test = {
 501         .send_index_none = true,
 502         .send_opcode = MGMT_OP_READ_INFO,
 503         .expect_status = MGMT_STATUS_INVALID_INDEX,
 504 };
 505
 506 static const struct generic_data read_unconf_index_list_invalid_param_test = {
 507         .send_index_none = true,
 508         .send_opcode = MGMT_OP_READ_UNCONF_INDEX_LIST,
 509         .send_param = dummy_data,
 510         .send_len = sizeof(dummy_data),
 511         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 512 };
 513
 514 static const struct generic_data read_unconf_index_list_invalid_index_test = {
 515         .send_opcode = MGMT_OP_READ_UNCONF_INDEX_LIST,
 516         .expect_status = MGMT_STATUS_INVALID_INDEX,
 517 };
 518
 519 static const struct generic_data read_config_info_invalid_param_test = {
 520         .send_opcode = MGMT_OP_READ_CONFIG_INFO,
 521         .send_param = dummy_data,
 522         .send_len = sizeof(dummy_data),
 523         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 524 };
 525
 526 static const struct generic_data read_config_info_invalid_index_test = {
 527         .send_index_none = true,
 528         .send_opcode = MGMT_OP_READ_CONFIG_INFO,
 529         .expect_status = MGMT_STATUS_INVALID_INDEX,
 530 };
 531
 532 static const struct generic_data read_ext_index_list_invalid_param_test = {
 533         .send_index_none = true,
 534         .send_opcode = MGMT_OP_READ_EXT_INDEX_LIST,
 535         .send_param = dummy_data,
 536         .send_len = sizeof(dummy_data),
 537         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 538 };
 539
 540 static const struct generic_data read_ext_index_list_invalid_index_test = {
 541         .send_opcode = MGMT_OP_READ_EXT_INDEX_LIST,
 542         .expect_status = MGMT_STATUS_INVALID_INDEX,
 543 };
 544
 545 static const char set_powered_on_param[] = { 0x01 };
 546 static const char set_powered_invalid_param[] = { 0x02 };
 547 static const char set_powered_garbage_param[] = { 0x01, 0x00 };
 548 static const char set_powered_settings_param[] = { 0x81, 0x00, 0x00, 0x00 };
 549
 550 static const struct generic_data set_powered_on_success_test = {
 551         .send_opcode = MGMT_OP_SET_POWERED,
 552         .send_param = set_powered_on_param,
 553         .send_len = sizeof(set_powered_on_param),
 554         .expect_status = MGMT_STATUS_SUCCESS,
 555         .expect_param = set_powered_settings_param,
 556         .expect_len = sizeof(set_powered_settings_param),
 557         .expect_settings_set = MGMT_SETTING_POWERED,
 558 };
 559
 560 static const struct generic_data set_powered_on_invalid_param_test_1 = {
 561         .send_opcode = MGMT_OP_SET_POWERED,
 562         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 563 };
 564
 565 static const struct generic_data set_powered_on_invalid_param_test_2 = {
 566         .send_opcode = MGMT_OP_SET_POWERED,
 567         .send_param = set_powered_invalid_param,
 568         .send_len = sizeof(set_powered_invalid_param),
 569         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 570 };
 571
 572 static const struct generic_data set_powered_on_invalid_param_test_3 = {
 573         .send_opcode = MGMT_OP_SET_POWERED,
 574         .send_param = set_powered_garbage_param,
 575         .send_len = sizeof(set_powered_garbage_param),
 576         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 577 };
 578
 579 static const struct generic_data set_powered_on_invalid_index_test = {
 580         .send_index_none = true,
 581         .send_opcode = MGMT_OP_SET_POWERED,
 582         .send_param = set_powered_on_param,
 583         .send_len = sizeof(set_powered_on_param),
 584         .expect_status = MGMT_STATUS_INVALID_INDEX,
 585 };
 586
 587 static uint16_t settings_powered_advertising_privacy[] = {
 588                                                 MGMT_OP_SET_PRIVACY,
 589                                                 MGMT_OP_SET_ADVERTISING,
 590                                                 MGMT_OP_SET_POWERED, 0 };
 591
 592 static const char set_adv_off_param[] = { 0x00 };
 593
 594 static const struct generic_data set_powered_on_privacy_adv_test = {
 595         .setup_settings = settings_powered_advertising_privacy,
 596         .send_opcode = MGMT_OP_SET_ADVERTISING,
 597         .send_param = set_adv_off_param,
 598         .send_len = sizeof(set_adv_off_param),
 599         .expect_status = MGMT_STATUS_SUCCESS,
 600         .expect_ignore_param = true,
 601 };
 602
 603 static const uint16_t settings_powered[] = { MGMT_OP_SET_POWERED, 0 };
 604
 605 static const char set_powered_off_param[] = { 0x00 };
 606 static const char set_powered_off_settings_param[] = { 0x80, 0x00, 0x00, 0x00 };
 607 static const char set_powered_off_class_of_dev[] = { 0x00, 0x00, 0x00 };
 608
 609 static const struct generic_data set_powered_off_success_test = {
 610         .setup_settings = settings_powered,
 611         .send_opcode = MGMT_OP_SET_POWERED,
 612         .send_param = set_powered_off_param,
 613         .send_len = sizeof(set_powered_off_param),
 614         .expect_status = MGMT_STATUS_SUCCESS,
 615         .expect_param = set_powered_off_settings_param,
 616         .expect_len = sizeof(set_powered_off_settings_param),
 617         .expect_settings_unset = MGMT_SETTING_POWERED,
 618 };
 619
 620 static const struct generic_data set_powered_off_class_test = {
 621         .send_opcode = MGMT_OP_SET_POWERED,
 622         .send_param = set_powered_off_param,
 623         .send_len = sizeof(set_powered_off_param),
 624         .expect_status = MGMT_STATUS_SUCCESS,
 625         .expect_param = set_powered_off_settings_param,
 626         .expect_len = sizeof(set_powered_off_settings_param),
 627         .expect_settings_unset = MGMT_SETTING_POWERED,
 628         .expect_alt_ev = MGMT_EV_CLASS_OF_DEV_CHANGED,
 629         .expect_alt_ev_param = set_powered_off_class_of_dev,
 630         .expect_alt_ev_len = sizeof(set_powered_off_class_of_dev),
 631 };
 632
 633 static const struct generic_data set_powered_off_invalid_param_test_1 = {
 634         .setup_settings = settings_powered,
 635         .send_opcode = MGMT_OP_SET_POWERED,
 636         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 637 };
 638
 639 static const struct generic_data set_powered_off_invalid_param_test_2 = {
 640         .setup_settings = settings_powered,
 641         .send_opcode = MGMT_OP_SET_POWERED,
 642         .send_param = set_powered_invalid_param,
 643         .send_len = sizeof(set_powered_invalid_param),
 644         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 645 };
 646
 647 static const struct generic_data set_powered_off_invalid_param_test_3 = {
 648         .setup_settings = settings_powered,
 649         .send_opcode = MGMT_OP_SET_POWERED,
 650         .send_param = set_powered_garbage_param,
 651         .send_len = sizeof(set_powered_garbage_param),
 652         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 653 };
 654
 655 static const char set_connectable_on_param[] = { 0x01 };
 656 static const char set_connectable_invalid_param[] = { 0x02 };
 657 static const char set_connectable_garbage_param[] = { 0x01, 0x00 };
 658 static const char set_connectable_settings_param_1[] = { 0x82, 0x00, 0x00, 0x00 };
 659 static const char set_connectable_settings_param_2[] = { 0x83, 0x00, 0x00, 0x00 };
 660 static const char set_connectable_scan_enable_param[] = { 0x02 };
 661
 662 static const struct generic_data set_connectable_on_success_test_1 = {
 663         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 664         .send_param = set_connectable_on_param,
 665         .send_len = sizeof(set_connectable_on_param),
 666         .expect_status = MGMT_STATUS_SUCCESS,
 667         .expect_param = set_connectable_settings_param_1,
 668         .expect_len = sizeof(set_connectable_settings_param_1),
 669         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 670 };
 671
 672 static const struct generic_data set_connectable_on_success_test_2 = {
 673         .setup_settings = settings_powered,
 674         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 675         .send_param = set_connectable_on_param,
 676         .send_len = sizeof(set_connectable_on_param),
 677         .expect_status = MGMT_STATUS_SUCCESS,
 678         .expect_param = set_connectable_settings_param_2,
 679         .expect_len = sizeof(set_connectable_settings_param_2),
 680         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 681         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 682         .expect_hci_param = set_connectable_scan_enable_param,
 683         .expect_hci_len = sizeof(set_connectable_scan_enable_param),
 684 };
 685
 686 static const struct generic_data set_connectable_on_invalid_param_test_1 = {
 687         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 688         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 689 };
 690
 691 static const struct generic_data set_connectable_on_invalid_param_test_2 = {
 692         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 693         .send_param = set_connectable_invalid_param,
 694         .send_len = sizeof(set_connectable_invalid_param),
 695         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 696 };
 697
 698 static const struct generic_data set_connectable_on_invalid_param_test_3 = {
 699         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 700         .send_param = set_connectable_garbage_param,
 701         .send_len = sizeof(set_connectable_garbage_param),
 702         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 703 };
 704
 705 static const struct generic_data set_connectable_on_invalid_index_test = {
 706         .send_index_none = true,
 707         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 708         .send_param = set_connectable_on_param,
 709         .send_len = sizeof(set_connectable_on_param),
 710         .expect_status = MGMT_STATUS_INVALID_INDEX,
 711 };
 712
 713 static uint16_t settings_powered_advertising[] = { MGMT_OP_SET_ADVERTISING,
 714                                                 MGMT_OP_SET_POWERED, 0 };
 715
 716 static const char set_connectable_le_settings_param_1[] = { 0x02, 0x02, 0x00, 0x00 };
 717 static const char set_connectable_le_settings_param_2[] = { 0x03, 0x02, 0x00, 0x00 };
 718 static const char set_connectable_le_settings_param_3[] = { 0x03, 0x06, 0x00, 0x00 };
 719
 720 static const struct generic_data set_connectable_on_le_test_1 = {
 721         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 722         .send_param = set_connectable_on_param,
 723         .send_len = sizeof(set_connectable_on_param),
 724         .expect_status = MGMT_STATUS_SUCCESS,
 725         .expect_param = set_connectable_le_settings_param_1,
 726         .expect_len = sizeof(set_connectable_le_settings_param_1),
 727         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 728 };
 729
 730 static const struct generic_data set_connectable_on_le_test_2 = {
 731         .setup_settings = settings_powered,
 732         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 733         .send_param = set_connectable_on_param,
 734         .send_len = sizeof(set_connectable_on_param),
 735         .expect_status = MGMT_STATUS_SUCCESS,
 736         .expect_param = set_connectable_le_settings_param_2,
 737         .expect_len = sizeof(set_connectable_le_settings_param_2),
 738         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 739 };
 740
 741 static uint8_t set_connectable_on_adv_param[] = {
 742                 0x00, 0x08,                             /* min_interval */
 743                 0x00, 0x08,                             /* max_interval */
 744                 0x00,                                   /* type */
 745                 0x00,                                   /* own_addr_type */
 746                 0x00,                                   /* direct_addr_type */
 747                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* direct_addr */
 748                 0x07,                                   /* channel_map */
 749                 0x00,                                   /* filter_policy */
 750 };
 751
 752 static const struct generic_data set_connectable_on_le_test_3 = {
 753         .setup_settings = settings_powered_advertising,
 754         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 755         .send_param = set_connectable_on_param,
 756         .send_len = sizeof(set_connectable_on_param),
 757         .expect_status = MGMT_STATUS_SUCCESS,
 758         .expect_param = set_connectable_le_settings_param_3,
 759         .expect_len = sizeof(set_connectable_le_settings_param_3),
 760         .expect_settings_set = MGMT_SETTING_CONNECTABLE,
 761         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
 762         .expect_hci_param = set_connectable_on_adv_param,
 763         .expect_hci_len = sizeof(set_connectable_on_adv_param),
 764 };
 765
 766 static const uint16_t settings_connectable[] = { MGMT_OP_SET_CONNECTABLE, 0 };
 767 static const uint16_t settings_powered_connectable[] = {
 768                                                 MGMT_OP_SET_CONNECTABLE,
 769                                                 MGMT_OP_SET_POWERED, 0 };
 770 static const uint16_t settings_powered_discoverable[] = {
 771                                                 MGMT_OP_SET_CONNECTABLE,
 772                                                 MGMT_OP_SET_DISCOVERABLE,
 773                                                 MGMT_OP_SET_POWERED, 0 };
 774
 775 static const char set_connectable_off_param[] = { 0x00 };
 776 static const char set_connectable_off_settings_1[] = { 0x80, 0x00, 0x00, 0x00 };
 777 static const char set_connectable_off_settings_2[] = { 0x81, 0x00, 0x00, 0x00 };
 778 static const char set_connectable_off_scan_enable_param[] = { 0x00 };
 779
 780 static const struct generic_data set_connectable_off_success_test_1 = {
 781         .setup_settings = settings_connectable,
 782         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 783         .send_param = set_connectable_off_param,
 784         .send_len = sizeof(set_connectable_off_param),
 785         .expect_status = MGMT_STATUS_SUCCESS,
 786         .expect_param = set_connectable_off_settings_1,
 787         .expect_len = sizeof(set_connectable_off_settings_1),
 788         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 789 };
 790
 791 static const struct generic_data set_connectable_off_success_test_2 = {
 792         .setup_settings = settings_powered_connectable,
 793         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 794         .send_param = set_connectable_off_param,
 795         .send_len = sizeof(set_connectable_off_param),
 796         .expect_status = MGMT_STATUS_SUCCESS,
 797         .expect_param = set_connectable_off_settings_2,
 798         .expect_len = sizeof(set_connectable_off_settings_2),
 799         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 800         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 801         .expect_hci_param = set_connectable_off_scan_enable_param,
 802         .expect_hci_len = sizeof(set_connectable_off_scan_enable_param),
 803 };
 804
 805 static const struct generic_data set_connectable_off_success_test_3 = {
 806         .setup_settings = settings_powered_discoverable,
 807         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 808         .send_param = set_connectable_off_param,
 809         .send_len = sizeof(set_connectable_off_param),
 810         .expect_status = MGMT_STATUS_SUCCESS,
 811         .expect_param = set_connectable_off_settings_2,
 812         .expect_len = sizeof(set_connectable_off_settings_2),
 813         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 814         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 815         .expect_hci_param = set_connectable_off_scan_enable_param,
 816         .expect_hci_len = sizeof(set_connectable_off_scan_enable_param),
 817 };
 818
 819 static const struct generic_data set_connectable_off_success_test_4 = {
 820         .setup_settings = settings_powered_discoverable,
 821         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 822         .send_param = set_connectable_off_param,
 823         .send_len = sizeof(set_connectable_off_param),
 824         .expect_status = MGMT_STATUS_SUCCESS,
 825         .expect_param = set_connectable_off_settings_2,
 826         .expect_len = sizeof(set_connectable_off_settings_2),
 827         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 828         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
 829         .expect_hci_param = set_connectable_scan_enable_param,
 830         .expect_hci_len = sizeof(set_connectable_scan_enable_param),
 831 };
 832
 833 static const char set_connectable_off_le_settings_1[] = { 0x00, 0x02, 0x00, 0x00 };
 834 static const char set_connectable_off_le_settings_2[] = { 0x01, 0x06, 0x00, 0x00 };
 835
 836 static uint16_t settings_le_connectable[] = { MGMT_OP_SET_LE,
 837                                                 MGMT_OP_SET_CONNECTABLE, 0 };
 838
 839 static const struct generic_data set_connectable_off_le_test_1 = {
 840         .setup_settings = settings_le_connectable,
 841         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 842         .send_param = set_connectable_off_param,
 843         .send_len = sizeof(set_connectable_off_param),
 844         .expect_status = MGMT_STATUS_SUCCESS,
 845         .expect_param = set_connectable_off_le_settings_1,
 846         .expect_len = sizeof(set_connectable_off_le_settings_1),
 847         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 848 };
 849
 850 static uint16_t settings_powered_le_connectable_advertising[] = {
 851                                         MGMT_OP_SET_LE,
 852                                         MGMT_OP_SET_CONNECTABLE,
 853                                         MGMT_OP_SET_ADVERTISING,
 854                                         MGMT_OP_SET_POWERED, 0 };
 855
 856 static uint8_t set_connectable_off_adv_param[] = {
 857                 0x00, 0x08,                             /* min_interval */
 858                 0x00, 0x08,                             /* max_interval */
 859                 0x03,                                   /* type */
 860                 0x01,                                   /* own_addr_type */
 861                 0x00,                                   /* direct_addr_type */
 862                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* direct_addr */
 863                 0x07,                                   /* channel_map */
 864                 0x00,                                   /* filter_policy */
 865 };
 866
 867 static const struct generic_data set_connectable_off_le_test_2 = {
 868         .setup_settings = settings_powered_le_connectable_advertising,
 869         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 870         .send_param = set_connectable_off_param,
 871         .send_len = sizeof(set_connectable_off_param),
 872         .expect_status = MGMT_STATUS_SUCCESS,
 873         .expect_param = set_connectable_off_le_settings_2,
 874         .expect_len = sizeof(set_connectable_off_le_settings_2),
 875         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 876         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
 877         .expect_hci_param = set_connectable_off_adv_param,
 878         .expect_hci_len = sizeof(set_connectable_off_adv_param),
 879 };
 880
 881 static uint16_t settings_powered_le_discoverable[] = {
 882                                         MGMT_OP_SET_LE,
 883                                         MGMT_OP_SET_CONNECTABLE,
 884                                         MGMT_OP_SET_POWERED,
 885                                         MGMT_OP_SET_DISCOVERABLE, 0 };
 886
 887 static uint16_t settings_powered_le_discoverable_advertising[] = {
 888                                         MGMT_OP_SET_LE,
 889                                         MGMT_OP_SET_CONNECTABLE,
 890                                         MGMT_OP_SET_ADVERTISING,
 891                                         MGMT_OP_SET_POWERED,
 892                                         MGMT_OP_SET_DISCOVERABLE, 0 };
 893
 894 static const struct generic_data set_connectable_off_le_test_3 = {
 895         .setup_settings = settings_powered_le_discoverable_advertising,
 896         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 897         .send_param = set_connectable_off_param,
 898         .send_len = sizeof(set_connectable_off_param),
 899         .expect_status = MGMT_STATUS_SUCCESS,
 900         .expect_param = set_connectable_off_le_settings_2,
 901         .expect_len = sizeof(set_connectable_off_le_settings_2),
 902         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 903         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
 904         .expect_hci_param = set_connectable_off_adv_param,
 905         .expect_hci_len = sizeof(set_connectable_off_adv_param),
 906 };
 907
 908 static const struct generic_data set_connectable_off_le_test_4 = {
 909         .setup_settings = settings_powered_le_discoverable_advertising,
 910         .setup_limited_discov = true,
 911         .send_opcode = MGMT_OP_SET_CONNECTABLE,
 912         .send_param = set_connectable_off_param,
 913         .send_len = sizeof(set_connectable_off_param),
 914         .expect_status = MGMT_STATUS_SUCCESS,
 915         .expect_param = set_connectable_off_le_settings_2,
 916         .expect_len = sizeof(set_connectable_off_le_settings_2),
 917         .expect_settings_unset = MGMT_SETTING_CONNECTABLE,
 918         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
 919         .expect_hci_param = set_connectable_off_adv_param,
 920         .expect_hci_len = sizeof(set_connectable_off_adv_param),
 921 };
 922
 923 static const char set_fast_conn_on_param[] = { 0x01 };
 924 static const char set_fast_conn_on_settings_1[] = { 0x87, 0x00, 0x00, 0x00 };
 925 static const char set_fast_conn_on_settings_2[] = { 0x85, 0x00, 0x00, 0x00 };
 926 static const char set_fast_conn_on_settings_3[] = { 0x84, 0x00, 0x00, 0x00 };
 927
 928 static const struct generic_data set_fast_conn_on_success_test_1 = {
 929         .setup_settings = settings_powered_connectable,
 930         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
 931         .send_param = set_fast_conn_on_param,
 932         .send_len = sizeof(set_fast_conn_on_param),
 933         .expect_status = MGMT_STATUS_SUCCESS,
 934         .expect_param = set_fast_conn_on_settings_1,
 935         .expect_len = sizeof(set_fast_conn_on_settings_1),
 936         .expect_settings_set = MGMT_SETTING_FAST_CONNECTABLE,
 937 };
 938
 939 static const struct generic_data set_fast_conn_on_success_test_2 = {
 940         .setup_settings = settings_powered,
 941         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
 942         .send_param = set_fast_conn_on_param,
 943         .send_len = sizeof(set_fast_conn_on_param),
 944         .expect_status = MGMT_STATUS_SUCCESS,
 945         .expect_param = set_fast_conn_on_settings_2,
 946         .expect_len = sizeof(set_fast_conn_on_settings_2),
 947         .expect_settings_set = MGMT_SETTING_FAST_CONNECTABLE,
 948 };
 949
 950 static const struct generic_data set_fast_conn_on_success_test_3 = {
 951         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
 952         .send_param = set_fast_conn_on_param,
 953         .send_len = sizeof(set_fast_conn_on_param),
 954         .expect_status = MGMT_STATUS_SUCCESS,
 955         .expect_param = set_fast_conn_on_settings_3,
 956         .expect_len = sizeof(set_fast_conn_on_settings_3),
 957         .expect_settings_set = MGMT_SETTING_FAST_CONNECTABLE,
 958 };
 959
 960 static const struct generic_data set_fast_conn_on_not_supported_test_1 = {
 961         .setup_settings = settings_powered_connectable,
 962         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
 963         .send_param = set_fast_conn_on_param,
 964         .send_len = sizeof(set_fast_conn_on_param),
 965         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
 966 };
 967
 968 static const char set_fast_conn_nval_param[] = { 0xff };
 969
 970 static const struct generic_data set_fast_conn_nval_param_test_1 = {
 971         .send_opcode = MGMT_OP_SET_FAST_CONNECTABLE,
 972         .send_param = set_fast_conn_nval_param,
 973         .send_len = sizeof(set_fast_conn_nval_param),
 974         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 975 };
 976
 977 static const char set_bondable_on_param[] = { 0x01 };
 978 static const char set_bondable_invalid_param[] = { 0x02 };
 979 static const char set_bondable_garbage_param[] = { 0x01, 0x00 };
 980 static const char set_bondable_settings_param[] = { 0x90, 0x00, 0x00, 0x00 };
 981
 982 static const struct generic_data set_bondable_on_success_test = {
 983         .send_opcode = MGMT_OP_SET_BONDABLE,
 984         .send_param = set_bondable_on_param,
 985         .send_len = sizeof(set_bondable_on_param),
 986         .expect_status = MGMT_STATUS_SUCCESS,
 987         .expect_param = set_bondable_settings_param,
 988         .expect_len = sizeof(set_bondable_settings_param),
 989         .expect_settings_set = MGMT_SETTING_BONDABLE,
 990 };
 991
 992 static const struct generic_data set_bondable_on_invalid_param_test_1 = {
 993         .send_opcode = MGMT_OP_SET_BONDABLE,
 994         .expect_status = MGMT_STATUS_INVALID_PARAMS,
 995 };
 996
 997 static const struct generic_data set_bondable_on_invalid_param_test_2 = {
 998         .send_opcode = MGMT_OP_SET_BONDABLE,
 999         .send_param = set_bondable_invalid_param,
1000         .send_len = sizeof(set_bondable_invalid_param),
1001         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1002 };
1003
1004 static const struct generic_data set_bondable_on_invalid_param_test_3 = {
1005         .send_opcode = MGMT_OP_SET_BONDABLE,
1006         .send_param = set_bondable_garbage_param,
1007         .send_len = sizeof(set_bondable_garbage_param),
1008         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1009 };
1010
1011 static const struct generic_data set_bondable_on_invalid_index_test = {
1012         .send_index_none = true,
1013         .send_opcode = MGMT_OP_SET_BONDABLE,
1014         .send_param = set_bondable_on_param,
1015         .send_len = sizeof(set_bondable_on_param),
1016         .expect_status = MGMT_STATUS_INVALID_INDEX,
1017 };
1018
1019 static const uint8_t set_discoverable_on_param[] = { 0x01, 0x00, 0x00 };
1020 static const uint8_t set_discoverable_timeout_param[] = { 0x01, 0x0a, 0x00 };
1021 static const uint8_t set_discoverable_invalid_param[] = { 0x02, 0x00, 0x00 };
1022 static const uint8_t set_discoverable_off_param[] = { 0x00, 0x00, 0x00 };
1023 static const uint8_t set_discoverable_offtimeout_param[] = { 0x00, 0x01, 0x00 };
1024 static const uint8_t set_discoverable_garbage_param[] = { 0x01, 0x00, 0x00, 0x00 };
1025 static const uint8_t set_discoverable_on_settings_param_1[] = { 0x8a, 0x00, 0x00, 0x00 };
1026 static const uint8_t set_discoverable_on_settings_param_2[] = { 0x8b, 0x00, 0x00, 0x00 };
1027 static const uint8_t set_discoverable_off_settings_param_1[] = { 0x82, 0x00, 0x00, 0x00 };
1028 static const uint8_t set_discoverable_off_settings_param_2[] = { 0x83, 0x00, 0x00, 0x00 };
1029 static const uint8_t set_discoverable_on_scan_enable_param[] = { 0x03 };
1030 static const uint8_t set_discoverable_off_scan_enable_param[] = { 0x02 };
1031
1032 static const struct generic_data set_discoverable_on_invalid_param_test_1 = {
1033         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1034         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1035 };
1036
1037 static const struct generic_data set_discoverable_on_invalid_param_test_2 = {
1038         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1039         .send_param = set_discoverable_invalid_param,
1040         .send_len = sizeof(set_discoverable_invalid_param),
1041         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1042 };
1043
1044 static const struct generic_data set_discoverable_on_invalid_param_test_3 = {
1045         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1046         .send_param = set_discoverable_garbage_param,
1047         .send_len = sizeof(set_discoverable_garbage_param),
1048         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1049 };
1050
1051 static const struct generic_data set_discoverable_on_invalid_param_test_4 = {
1052         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1053         .send_param = set_discoverable_offtimeout_param,
1054         .send_len = sizeof(set_discoverable_offtimeout_param),
1055         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1056 };
1057
1058 static const struct generic_data set_discoverable_on_not_powered_test_1 = {
1059         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1060         .send_param = set_discoverable_timeout_param,
1061         .send_len = sizeof(set_discoverable_timeout_param),
1062         .expect_status = MGMT_STATUS_NOT_POWERED,
1063 };
1064
1065 static const struct generic_data set_discoverable_on_not_powered_test_2 = {
1066         .setup_settings = settings_connectable,
1067         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1068         .send_param = set_discoverable_timeout_param,
1069         .send_len = sizeof(set_discoverable_timeout_param),
1070         .expect_status = MGMT_STATUS_NOT_POWERED,
1071 };
1072
1073 static const struct generic_data set_discoverable_on_rejected_test_1 = {
1074         .setup_settings = settings_powered,
1075         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1076         .send_param = set_discoverable_on_param,
1077         .send_len = sizeof(set_discoverable_on_param),
1078         .expect_status = MGMT_STATUS_REJECTED,
1079 };
1080
1081 static const struct generic_data set_discoverable_on_rejected_test_2 = {
1082         .setup_settings = settings_powered,
1083         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1084         .send_param = set_discoverable_on_param,
1085         .send_len = sizeof(set_discoverable_on_param),
1086         .expect_status = MGMT_STATUS_REJECTED,
1087 };
1088
1089 static const struct generic_data set_discoverable_on_rejected_test_3 = {
1090         .setup_settings = settings_powered,
1091         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1092         .send_param = set_discoverable_timeout_param,
1093         .send_len = sizeof(set_discoverable_timeout_param),
1094         .expect_status = MGMT_STATUS_REJECTED,
1095 };
1096
1097 static const struct generic_data set_discoverable_on_success_test_1 = {
1098         .setup_settings = settings_connectable,
1099         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1100         .send_param = set_discoverable_on_param,
1101         .send_len = sizeof(set_discoverable_on_param),
1102         .expect_status = MGMT_STATUS_SUCCESS,
1103         .expect_param = set_discoverable_on_settings_param_1,
1104         .expect_len = sizeof(set_discoverable_on_settings_param_1),
1105         .expect_settings_set = MGMT_SETTING_DISCOVERABLE,
1106 };
1107
1108 static const struct generic_data set_discoverable_on_success_test_2 = {
1109         .setup_settings = settings_powered_connectable,
1110         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1111         .send_param = set_discoverable_on_param,
1112         .send_len = sizeof(set_discoverable_on_param),
1113         .expect_status = MGMT_STATUS_SUCCESS,
1114         .expect_param = set_discoverable_on_settings_param_2,
1115         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1116         .expect_settings_set = MGMT_SETTING_DISCOVERABLE,
1117         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
1118         .expect_hci_param = set_discoverable_on_scan_enable_param,
1119         .expect_hci_len = sizeof(set_discoverable_on_scan_enable_param),
1120 };
1121
1122 static uint8_t set_discov_on_le_param[] = { 0x0b, 0x06, 0x00, 0x00 };
1123 static uint8_t set_discov_adv_data[32] = { 0x06, 0x02, 0x01, 0x06,
1124                                                                 0x02, 0x0a, };
1125
1126 static const struct generic_data set_discov_on_le_success_1 = {
1127         .setup_settings = settings_powered_le_connectable_advertising,
1128         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1129         .send_param = set_discoverable_on_param,
1130         .send_len = sizeof(set_discoverable_on_param),
1131         .expect_status = MGMT_STATUS_SUCCESS,
1132         .expect_param = set_discov_on_le_param,
1133         .expect_len = sizeof(set_discov_on_le_param),
1134         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
1135         .expect_hci_param = set_discov_adv_data,
1136         .expect_hci_len = sizeof(set_discov_adv_data),
1137 };
1138
1139 static const struct generic_data set_discoverable_off_success_test_1 = {
1140         .setup_settings = settings_connectable,
1141         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1142         .send_param = set_discoverable_off_param,
1143         .send_len = sizeof(set_discoverable_off_param),
1144         .expect_status = MGMT_STATUS_SUCCESS,
1145         .expect_param = set_discoverable_off_settings_param_1,
1146         .expect_len = sizeof(set_discoverable_off_settings_param_1),
1147 };
1148
1149 static const struct generic_data set_discoverable_off_success_test_2 = {
1150         .setup_settings = settings_powered_discoverable,
1151         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1152         .send_param = set_discoverable_off_param,
1153         .send_len = sizeof(set_discoverable_off_param),
1154         .expect_status = MGMT_STATUS_SUCCESS,
1155         .expect_param = set_discoverable_off_settings_param_2,
1156         .expect_len = sizeof(set_discoverable_off_settings_param_2),
1157         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
1158         .expect_hci_param = set_discoverable_off_scan_enable_param,
1159         .expect_hci_len = sizeof(set_discoverable_off_scan_enable_param),
1160 };
1161
1162 static const uint8_t set_limited_discov_on_param[] = { 0x02, 0x01, 0x00 };
1163
1164 static const struct generic_data set_limited_discov_on_success_1 = {
1165         .setup_settings = settings_powered_connectable,
1166         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1167         .send_param = set_limited_discov_on_param,
1168         .send_len = sizeof(set_limited_discov_on_param),
1169         .expect_status = MGMT_STATUS_SUCCESS,
1170         .expect_param = set_discoverable_on_settings_param_2,
1171         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1172         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
1173         .expect_hci_param = set_discoverable_on_scan_enable_param,
1174         .expect_hci_len = sizeof(set_discoverable_on_scan_enable_param),
1175 };
1176
1177 static uint8_t write_current_iac_lap_limited[] = { 0x01, 0x00, 0x8b, 0x9e };
1178
1179 static const struct generic_data set_limited_discov_on_success_2 = {
1180         .setup_settings = settings_powered_connectable,
1181         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1182         .send_param = set_limited_discov_on_param,
1183         .send_len = sizeof(set_limited_discov_on_param),
1184         .expect_status = MGMT_STATUS_SUCCESS,
1185         .expect_param = set_discoverable_on_settings_param_2,
1186         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1187         .expect_hci_command = BT_HCI_CMD_WRITE_CURRENT_IAC_LAP,
1188         .expect_hci_param = write_current_iac_lap_limited,
1189         .expect_hci_len = sizeof(write_current_iac_lap_limited),
1190 };
1191
1192 static uint8_t write_cod_limited[] = { 0x00, 0x20, 0x00 };
1193
1194 static const struct generic_data set_limited_discov_on_success_3 = {
1195         .setup_settings = settings_powered_connectable,
1196         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1197         .send_param = set_limited_discov_on_param,
1198         .send_len = sizeof(set_limited_discov_on_param),
1199         .expect_status = MGMT_STATUS_SUCCESS,
1200         .expect_param = set_discoverable_on_settings_param_2,
1201         .expect_len = sizeof(set_discoverable_on_settings_param_2),
1202         .expect_hci_command = BT_HCI_CMD_WRITE_CLASS_OF_DEV,
1203         .expect_hci_param = write_cod_limited,
1204         .expect_hci_len = sizeof(write_cod_limited),
1205 };
1206
1207 static uint8_t set_limited_discov_adv_data[32] = { 0x06, 0x02, 0x01, 0x05,
1208                                                                 0x02, 0x0a, };
1209
1210 static const struct generic_data set_limited_discov_on_le_success_1 = {
1211         .setup_settings = settings_powered_le_connectable_advertising,
1212         .send_opcode = MGMT_OP_SET_DISCOVERABLE,
1213         .send_param = set_limited_discov_on_param,
1214         .send_len = sizeof(set_limited_discov_on_param),
1215         .expect_status = MGMT_STATUS_SUCCESS,
1216         .expect_param = set_discov_on_le_param,
1217         .expect_len = sizeof(set_discov_on_le_param),
1218         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
1219         .expect_hci_param = set_limited_discov_adv_data,
1220         .expect_hci_len = sizeof(set_limited_discov_adv_data),
1221 };
1222
1223 static uint16_t settings_link_sec[] = { MGMT_OP_SET_LINK_SECURITY, 0 };
1224
1225 static const char set_link_sec_on_param[] = { 0x01 };
1226 static const char set_link_sec_invalid_param[] = { 0x02 };
1227 static const char set_link_sec_garbage_param[] = { 0x01, 0x00 };
1228 static const char set_link_sec_settings_param_1[] = { 0xa0, 0x00, 0x00, 0x00 };
1229 static const char set_link_sec_settings_param_2[] = { 0xa1, 0x00, 0x00, 0x00 };
1230 static const char set_link_sec_auth_enable_param[] = { 0x01 };
1231
1232 static const struct generic_data set_link_sec_on_success_test_1 = {
1233         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1234         .send_param = set_link_sec_on_param,
1235         .send_len = sizeof(set_link_sec_on_param),
1236         .expect_status = MGMT_STATUS_SUCCESS,
1237         .expect_param = set_link_sec_settings_param_1,
1238         .expect_len = sizeof(set_link_sec_settings_param_1),
1239         .expect_settings_set = MGMT_SETTING_LINK_SECURITY,
1240 };
1241
1242 static const struct generic_data set_link_sec_on_success_test_2 = {
1243         .setup_settings = settings_powered,
1244         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1245         .send_param = set_link_sec_on_param,
1246         .send_len = sizeof(set_link_sec_on_param),
1247         .expect_status = MGMT_STATUS_SUCCESS,
1248         .expect_param = set_link_sec_settings_param_2,
1249         .expect_len = sizeof(set_link_sec_settings_param_2),
1250         .expect_settings_set = MGMT_SETTING_LINK_SECURITY,
1251         .expect_hci_command = BT_HCI_CMD_WRITE_AUTH_ENABLE,
1252         .expect_hci_param = set_link_sec_auth_enable_param,
1253         .expect_hci_len = sizeof(set_link_sec_auth_enable_param),
1254 };
1255
1256 static const struct generic_data set_link_sec_on_success_test_3 = {
1257         .setup_settings = settings_link_sec,
1258         .send_opcode = MGMT_OP_SET_POWERED,
1259         .send_param = set_powered_on_param,
1260         .send_len = sizeof(set_powered_on_param),
1261         .expect_status = MGMT_STATUS_SUCCESS,
1262         .expect_param = set_link_sec_settings_param_2,
1263         .expect_len = sizeof(set_link_sec_settings_param_2),
1264         .expect_settings_set = MGMT_SETTING_LINK_SECURITY,
1265         .expect_hci_command = BT_HCI_CMD_WRITE_AUTH_ENABLE,
1266         .expect_hci_param = set_link_sec_auth_enable_param,
1267         .expect_hci_len = sizeof(set_link_sec_auth_enable_param),
1268 };
1269
1270 static const struct generic_data set_link_sec_on_invalid_param_test_1 = {
1271         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1272         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1273 };
1274
1275 static const struct generic_data set_link_sec_on_invalid_param_test_2 = {
1276         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1277         .send_param = set_link_sec_invalid_param,
1278         .send_len = sizeof(set_link_sec_invalid_param),
1279         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1280 };
1281
1282 static const struct generic_data set_link_sec_on_invalid_param_test_3 = {
1283         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1284         .send_param = set_link_sec_garbage_param,
1285         .send_len = sizeof(set_link_sec_garbage_param),
1286         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1287 };
1288
1289 static const struct generic_data set_link_sec_on_invalid_index_test = {
1290         .send_index_none = true,
1291         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1292         .send_param = set_link_sec_on_param,
1293         .send_len = sizeof(set_link_sec_on_param),
1294         .expect_status = MGMT_STATUS_INVALID_INDEX,
1295 };
1296
1297 static const uint16_t settings_powered_link_sec[] = {
1298                                                 MGMT_OP_SET_LINK_SECURITY,
1299                                                 MGMT_OP_SET_POWERED, 0 };
1300
1301 static const char set_link_sec_off_param[] = { 0x00 };
1302 static const char set_link_sec_off_settings_1[] = { 0x80, 0x00, 0x00, 0x00 };
1303 static const char set_link_sec_off_settings_2[] = { 0x81, 0x00, 0x00, 0x00 };
1304 static const char set_link_sec_off_auth_enable_param[] = { 0x00 };
1305
1306 static const struct generic_data set_link_sec_off_success_test_1 = {
1307         .setup_settings = settings_link_sec,
1308         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1309         .send_param = set_link_sec_off_param,
1310         .send_len = sizeof(set_link_sec_off_param),
1311         .expect_status = MGMT_STATUS_SUCCESS,
1312         .expect_param = set_link_sec_off_settings_1,
1313         .expect_len = sizeof(set_link_sec_off_settings_1),
1314         .expect_settings_unset = MGMT_SETTING_LINK_SECURITY,
1315 };
1316
1317 static const struct generic_data set_link_sec_off_success_test_2 = {
1318         .setup_settings = settings_powered_link_sec,
1319         .send_opcode = MGMT_OP_SET_LINK_SECURITY,
1320         .send_param = set_link_sec_off_param,
1321         .send_len = sizeof(set_link_sec_off_param),
1322         .expect_status = MGMT_STATUS_SUCCESS,
1323         .expect_param = set_link_sec_off_settings_2,
1324         .expect_len = sizeof(set_link_sec_off_settings_2),
1325         .expect_settings_unset = MGMT_SETTING_LINK_SECURITY,
1326         .expect_hci_command = BT_HCI_CMD_WRITE_AUTH_ENABLE,
1327         .expect_hci_param = set_link_sec_off_auth_enable_param,
1328         .expect_hci_len = sizeof(set_link_sec_off_auth_enable_param),
1329 };
1330
1331 static uint16_t settings_ssp[] = { MGMT_OP_SET_SSP, 0 };
1332
1333 static const char set_ssp_on_param[] = { 0x01 };
1334 static const char set_ssp_invalid_param[] = { 0x02 };
1335 static const char set_ssp_garbage_param[] = { 0x01, 0x00 };
1336 static const char set_ssp_settings_param_1[] = { 0xc0, 0x00, 0x00, 0x00 };
1337 static const char set_ssp_settings_param_2[] = { 0xc1, 0x00, 0x00, 0x00 };
1338 static const char set_ssp_on_write_ssp_mode_param[] = { 0x01 };
1339
1340 static const struct generic_data set_ssp_on_success_test_1 = {
1341         .send_opcode = MGMT_OP_SET_SSP,
1342         .send_param = set_ssp_on_param,
1343         .send_len = sizeof(set_ssp_on_param),
1344         .expect_status = MGMT_STATUS_SUCCESS,
1345         .expect_param = set_ssp_settings_param_1,
1346         .expect_len = sizeof(set_ssp_settings_param_1),
1347         .expect_settings_set = MGMT_SETTING_SSP,
1348 };
1349
1350 static const struct generic_data set_ssp_on_success_test_2 = {
1351         .setup_settings = settings_powered,
1352         .send_opcode = MGMT_OP_SET_SSP,
1353         .send_param = set_ssp_on_param,
1354         .send_len = sizeof(set_ssp_on_param),
1355         .expect_status = MGMT_STATUS_SUCCESS,
1356         .expect_param = set_ssp_settings_param_2,
1357         .expect_len = sizeof(set_ssp_settings_param_2),
1358         .expect_settings_set = MGMT_SETTING_SSP,
1359         .expect_hci_command = BT_HCI_CMD_WRITE_SIMPLE_PAIRING_MODE,
1360         .expect_hci_param = set_ssp_on_write_ssp_mode_param,
1361         .expect_hci_len = sizeof(set_ssp_on_write_ssp_mode_param),
1362 };
1363
1364 static const struct generic_data set_ssp_on_success_test_3 = {
1365         .setup_settings = settings_ssp,
1366         .send_opcode = MGMT_OP_SET_POWERED,
1367         .send_param = set_powered_on_param,
1368         .send_len = sizeof(set_powered_on_param),
1369         .expect_status = MGMT_STATUS_SUCCESS,
1370         .expect_param = set_ssp_settings_param_2,
1371         .expect_len = sizeof(set_ssp_settings_param_2),
1372         .expect_settings_set = MGMT_SETTING_SSP,
1373         .expect_hci_command = BT_HCI_CMD_WRITE_SIMPLE_PAIRING_MODE,
1374         .expect_hci_param = set_ssp_on_write_ssp_mode_param,
1375         .expect_hci_len = sizeof(set_ssp_on_write_ssp_mode_param),
1376 };
1377
1378 static const struct generic_data set_ssp_on_invalid_param_test_1 = {
1379         .send_opcode = MGMT_OP_SET_SSP,
1380         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1381 };
1382
1383 static const struct generic_data set_ssp_on_invalid_param_test_2 = {
1384         .send_opcode = MGMT_OP_SET_SSP,
1385         .send_param = set_ssp_invalid_param,
1386         .send_len = sizeof(set_ssp_invalid_param),
1387         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1388 };
1389
1390 static const struct generic_data set_ssp_on_invalid_param_test_3 = {
1391         .send_opcode = MGMT_OP_SET_SSP,
1392         .send_param = set_ssp_garbage_param,
1393         .send_len = sizeof(set_ssp_garbage_param),
1394         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1395 };
1396
1397 static const struct generic_data set_ssp_on_invalid_index_test = {
1398         .send_index_none = true,
1399         .send_opcode = MGMT_OP_SET_SSP,
1400         .send_param = set_ssp_on_param,
1401         .send_len = sizeof(set_ssp_on_param),
1402         .expect_status = MGMT_STATUS_INVALID_INDEX,
1403 };
1404
1405 static uint16_t settings_powered_ssp[] = { MGMT_OP_SET_SSP,
1406                                                 MGMT_OP_SET_POWERED, 0 };
1407
1408 static uint16_t settings_powered_sc[] = { MGMT_OP_SET_SSP,
1409                                                 MGMT_OP_SET_SECURE_CONN,
1410                                                 MGMT_OP_SET_POWERED, 0 };
1411
1412 static const char set_sc_on_param[] = { 0x01 };
1413 static const char set_sc_only_on_param[] = { 0x02 };
1414 static const char set_sc_invalid_param[] = { 0x03 };
1415 static const char set_sc_garbage_param[] = { 0x01, 0x00 };
1416 static const char set_sc_settings_param_1[] = { 0xc0, 0x08, 0x00, 0x00 };
1417 static const char set_sc_settings_param_2[] = { 0xc1, 0x08, 0x00, 0x00 };
1418 static const char set_sc_on_write_sc_support_param[] = { 0x01 };
1419
1420 static const struct generic_data set_sc_on_success_test_1 = {
1421         .setup_settings = settings_ssp,
1422         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1423         .send_param = set_sc_on_param,
1424         .send_len = sizeof(set_sc_on_param),
1425         .expect_status = MGMT_STATUS_SUCCESS,
1426         .expect_param = set_sc_settings_param_1,
1427         .expect_len = sizeof(set_sc_settings_param_1),
1428         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1429 };
1430
1431 static const struct generic_data set_sc_on_success_test_2 = {
1432         .setup_settings = settings_powered_ssp,
1433         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1434         .send_param = set_sc_on_param,
1435         .send_len = sizeof(set_sc_on_param),
1436         .expect_status = MGMT_STATUS_SUCCESS,
1437         .expect_param = set_sc_settings_param_2,
1438         .expect_len = sizeof(set_sc_settings_param_2),
1439         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1440         .expect_hci_command = BT_HCI_CMD_WRITE_SECURE_CONN_SUPPORT,
1441         .expect_hci_param = set_sc_on_write_sc_support_param,
1442         .expect_hci_len = sizeof(set_sc_on_write_sc_support_param),
1443 };
1444
1445 static const struct generic_data set_sc_on_invalid_param_test_1 = {
1446         .setup_settings = settings_ssp,
1447         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1448         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1449 };
1450
1451 static const struct generic_data set_sc_on_invalid_param_test_2 = {
1452         .setup_settings = settings_ssp,
1453         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1454         .send_param = set_sc_invalid_param,
1455         .send_len = sizeof(set_sc_invalid_param),
1456         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1457 };
1458
1459 static const struct generic_data set_sc_on_invalid_param_test_3 = {
1460         .setup_settings = settings_ssp,
1461         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1462         .send_param = set_sc_garbage_param,
1463         .send_len = sizeof(set_sc_garbage_param),
1464         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1465 };
1466
1467 static const struct generic_data set_sc_on_invalid_index_test = {
1468         .setup_settings = settings_ssp,
1469         .send_index_none = true,
1470         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1471         .send_param = set_sc_on_param,
1472         .send_len = sizeof(set_sc_on_param),
1473         .expect_status = MGMT_STATUS_INVALID_INDEX,
1474 };
1475
1476 static const struct generic_data set_sc_on_not_supported_test_1 = {
1477         .setup_settings = settings_ssp,
1478         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1479         .send_param = set_sc_on_param,
1480         .send_len = sizeof(set_sc_on_param),
1481         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1482 };
1483
1484 static const struct generic_data set_sc_on_not_supported_test_2 = {
1485         .setup_settings = settings_powered_ssp,
1486         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1487         .send_param = set_sc_on_param,
1488         .send_len = sizeof(set_sc_on_param),
1489         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1490 };
1491
1492 static const struct generic_data set_sc_only_on_success_test_1 = {
1493         .setup_settings = settings_ssp,
1494         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1495         .send_param = set_sc_only_on_param,
1496         .send_len = sizeof(set_sc_only_on_param),
1497         .expect_status = MGMT_STATUS_SUCCESS,
1498         .expect_param = set_sc_settings_param_1,
1499         .expect_len = sizeof(set_sc_settings_param_1),
1500         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1501 };
1502
1503 static const struct generic_data set_sc_only_on_success_test_2 = {
1504         .setup_settings = settings_powered_ssp,
1505         .send_opcode = MGMT_OP_SET_SECURE_CONN,
1506         .send_param = set_sc_only_on_param,
1507         .send_len = sizeof(set_sc_only_on_param),
1508         .expect_status = MGMT_STATUS_SUCCESS,
1509         .expect_param = set_sc_settings_param_2,
1510         .expect_len = sizeof(set_sc_settings_param_2),
1511         .expect_settings_set = MGMT_SETTING_SECURE_CONN,
1512         .expect_hci_command = BT_HCI_CMD_WRITE_SECURE_CONN_SUPPORT,
1513         .expect_hci_param = set_sc_on_write_sc_support_param,
1514         .expect_hci_len = sizeof(set_sc_on_write_sc_support_param),
1515 };
1516
1517 static const char set_hs_on_param[] = { 0x01 };
1518 static const char set_hs_invalid_param[] = { 0x02 };
1519 static const char set_hs_garbage_param[] = { 0x01, 0x00 };
1520 static const char set_hs_settings_param_1[] = { 0xc0, 0x01, 0x00, 0x00 };
1521
1522 static const struct generic_data set_hs_on_success_test = {
1523         .setup_settings = settings_ssp,
1524         .send_opcode = MGMT_OP_SET_HS,
1525         .send_param = set_hs_on_param,
1526         .send_len = sizeof(set_hs_on_param),
1527         .expect_status = MGMT_STATUS_SUCCESS,
1528         .expect_param = set_hs_settings_param_1,
1529         .expect_len = sizeof(set_hs_settings_param_1),
1530         .expect_settings_set = MGMT_SETTING_HS,
1531 };
1532
1533 static const struct generic_data set_hs_on_invalid_param_test_1 = {
1534         .setup_settings = settings_ssp,
1535         .send_opcode = MGMT_OP_SET_HS,
1536         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1537 };
1538
1539 static const struct generic_data set_hs_on_invalid_param_test_2 = {
1540         .setup_settings = settings_ssp,
1541         .send_opcode = MGMT_OP_SET_HS,
1542         .send_param = set_hs_invalid_param,
1543         .send_len = sizeof(set_hs_invalid_param),
1544         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1545 };
1546
1547 static const struct generic_data set_hs_on_invalid_param_test_3 = {
1548         .setup_settings = settings_ssp,
1549         .send_opcode = MGMT_OP_SET_HS,
1550         .send_param = set_hs_garbage_param,
1551         .send_len = sizeof(set_hs_garbage_param),
1552         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1553 };
1554
1555 static const struct generic_data set_hs_on_invalid_index_test = {
1556         .setup_settings = settings_ssp,
1557         .send_index_none = true,
1558         .send_opcode = MGMT_OP_SET_HS,
1559         .send_param = set_hs_on_param,
1560         .send_len = sizeof(set_hs_on_param),
1561         .expect_status = MGMT_STATUS_INVALID_INDEX,
1562 };
1563
1564 static uint16_t settings_le[] = { MGMT_OP_SET_LE, 0 };
1565
1566 static const char set_le_on_param[] = { 0x01 };
1567 static const char set_le_off_param[] = { 0x00 };
1568 static const char set_le_invalid_param[] = { 0x02 };
1569 static const char set_le_garbage_param[] = { 0x01, 0x00 };
1570 static const char set_le_settings_param_1[] = { 0x80, 0x02, 0x00, 0x00 };
1571 static const char set_le_settings_param_2[] = { 0x81, 0x02, 0x00, 0x00 };
1572 static const char set_le_on_write_le_host_param[] = { 0x01, 0x00 };
1573
1574 static const struct generic_data set_le_on_success_test_1 = {
1575         .send_opcode = MGMT_OP_SET_LE,
1576         .send_param = set_le_on_param,
1577         .send_len = sizeof(set_le_on_param),
1578         .expect_status = MGMT_STATUS_SUCCESS,
1579         .expect_param = set_le_settings_param_1,
1580         .expect_len = sizeof(set_le_settings_param_1),
1581         .expect_settings_set = MGMT_SETTING_LE,
1582 };
1583
1584 static const struct generic_data set_le_on_success_test_2 = {
1585         .setup_settings = settings_powered,
1586         .send_opcode = MGMT_OP_SET_LE,
1587         .send_param = set_le_on_param,
1588         .send_len = sizeof(set_le_on_param),
1589         .expect_status = MGMT_STATUS_SUCCESS,
1590         .expect_param = set_le_settings_param_2,
1591         .expect_len = sizeof(set_le_settings_param_2),
1592         .expect_settings_set = MGMT_SETTING_LE,
1593         .expect_hci_command = BT_HCI_CMD_WRITE_LE_HOST_SUPPORTED,
1594         .expect_hci_param = set_le_on_write_le_host_param,
1595         .expect_hci_len = sizeof(set_le_on_write_le_host_param),
1596 };
1597
1598 static const struct generic_data set_le_on_success_test_3 = {
1599         .setup_settings = settings_le,
1600         .send_opcode = MGMT_OP_SET_POWERED,
1601         .send_param = set_powered_on_param,
1602         .send_len = sizeof(set_powered_on_param),
1603         .expect_status = MGMT_STATUS_SUCCESS,
1604         .expect_param = set_le_settings_param_2,
1605         .expect_len = sizeof(set_le_settings_param_2),
1606         .expect_settings_set = MGMT_SETTING_LE,
1607         .expect_hci_command = BT_HCI_CMD_WRITE_LE_HOST_SUPPORTED,
1608         .expect_hci_param = set_le_on_write_le_host_param,
1609         .expect_hci_len = sizeof(set_le_on_write_le_host_param),
1610 };
1611
1612 static const struct generic_data set_le_on_invalid_param_test_1 = {
1613         .send_opcode = MGMT_OP_SET_LE,
1614         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1615 };
1616
1617 static const struct generic_data set_le_on_invalid_param_test_2 = {
1618         .send_opcode = MGMT_OP_SET_LE,
1619         .send_param = set_le_invalid_param,
1620         .send_len = sizeof(set_le_invalid_param),
1621         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1622 };
1623
1624 static const struct generic_data set_le_on_invalid_param_test_3 = {
1625         .send_opcode = MGMT_OP_SET_LE,
1626         .send_param = set_le_garbage_param,
1627         .send_len = sizeof(set_le_garbage_param),
1628         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1629 };
1630
1631 static const struct generic_data set_le_on_invalid_index_test = {
1632         .send_index_none = true,
1633         .send_opcode = MGMT_OP_SET_LE,
1634         .send_param = set_le_on_param,
1635         .send_len = sizeof(set_le_on_param),
1636         .expect_status = MGMT_STATUS_INVALID_INDEX,
1637 };
1638
1639 static uint16_t settings_powered_le[] = { MGMT_OP_SET_LE,
1640                                         MGMT_OP_SET_POWERED, 0 };
1641
1642 static const char set_adv_on_param[] = { 0x01 };
1643 static const char set_adv_settings_param_1[] = { 0x80, 0x06, 0x00, 0x00 };
1644 static const char set_adv_settings_param_2[] = { 0x81, 0x06, 0x00, 0x00 };
1645 static const char set_adv_on_set_adv_enable_param[] = { 0x01 };
1646 static const char set_adv_on_set_adv_disable_param[] = { 0x00 };
1647
1648 static const struct generic_data set_adv_on_success_test_1 = {
1649         .setup_settings = settings_le,
1650         .send_opcode = MGMT_OP_SET_ADVERTISING,
1651         .send_param = set_adv_on_param,
1652         .send_len = sizeof(set_adv_on_param),
1653         .expect_status = MGMT_STATUS_SUCCESS,
1654         .expect_param = set_adv_settings_param_1,
1655         .expect_len = sizeof(set_adv_settings_param_1),
1656         .expect_settings_set = MGMT_SETTING_ADVERTISING,
1657 };
1658
1659 static const struct generic_data set_adv_on_success_test_2 = {
1660         .setup_settings = settings_powered_le,
1661         .send_opcode = MGMT_OP_SET_ADVERTISING,
1662         .send_param = set_adv_on_param,
1663         .send_len = sizeof(set_adv_on_param),
1664         .expect_status = MGMT_STATUS_SUCCESS,
1665         .expect_param = set_adv_settings_param_2,
1666         .expect_len = sizeof(set_adv_settings_param_2),
1667         .expect_settings_set = MGMT_SETTING_ADVERTISING,
1668         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
1669         .expect_hci_param = set_adv_on_set_adv_enable_param,
1670         .expect_hci_len = sizeof(set_adv_on_set_adv_enable_param),
1671 };
1672
1673 static const struct generic_data set_adv_on_rejected_test_1 = {
1674         .setup_settings = settings_powered,
1675         .send_opcode = MGMT_OP_SET_ADVERTISING,
1676         .send_param = set_adv_on_param,
1677         .send_len = sizeof(set_adv_on_param),
1678         .expect_status = MGMT_STATUS_REJECTED,
1679 };
1680
1681 static const char set_bredr_off_param[] = { 0x00 };
1682 static const char set_bredr_on_param[] = { 0x01 };
1683 static const char set_bredr_invalid_param[] = { 0x02 };
1684 static const char set_bredr_settings_param_1[] = { 0x00, 0x02, 0x00, 0x00 };
1685 static const char set_bredr_settings_param_2[] = { 0x80, 0x02, 0x00, 0x00 };
1686 static const char set_bredr_settings_param_3[] = { 0x81, 0x02, 0x00, 0x00 };
1687
1688 static const struct generic_data set_bredr_off_success_test_1 = {
1689         .setup_settings = settings_le,
1690         .send_opcode = MGMT_OP_SET_BREDR,
1691         .send_param = set_bredr_off_param,
1692         .send_len = sizeof(set_bredr_off_param),
1693         .expect_status = MGMT_STATUS_SUCCESS,
1694         .expect_param = set_bredr_settings_param_1,
1695         .expect_len = sizeof(set_bredr_settings_param_1),
1696         .expect_settings_unset = MGMT_SETTING_BREDR,
1697 };
1698
1699 static const struct generic_data set_bredr_on_success_test_1 = {
1700         .setup_settings = settings_le,
1701         .setup_nobredr = true,
1702         .send_opcode = MGMT_OP_SET_BREDR,
1703         .send_param = set_bredr_on_param,
1704         .send_len = sizeof(set_bredr_on_param),
1705         .expect_status = MGMT_STATUS_SUCCESS,
1706         .expect_param = set_bredr_settings_param_2,
1707         .expect_len = sizeof(set_bredr_settings_param_2),
1708         .expect_settings_set = MGMT_SETTING_BREDR,
1709 };
1710
1711 static const struct generic_data set_bredr_on_success_test_2 = {
1712         .setup_settings = settings_powered_le,
1713         .setup_nobredr = true,
1714         .send_opcode = MGMT_OP_SET_BREDR,
1715         .send_param = set_bredr_on_param,
1716         .send_len = sizeof(set_bredr_on_param),
1717         .expect_status = MGMT_STATUS_SUCCESS,
1718         .expect_param = set_bredr_settings_param_3,
1719         .expect_len = sizeof(set_bredr_settings_param_3),
1720         .expect_settings_set = MGMT_SETTING_BREDR,
1721 };
1722
1723 static const struct generic_data set_bredr_off_notsupp_test = {
1724         .send_opcode = MGMT_OP_SET_BREDR,
1725         .send_param = set_bredr_off_param,
1726         .send_len = sizeof(set_bredr_off_param),
1727         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
1728 };
1729
1730 static const struct generic_data set_bredr_off_failure_test_1 = {
1731         .setup_settings = settings_powered_le,
1732         .send_opcode = MGMT_OP_SET_BREDR,
1733         .send_param = set_bredr_off_param,
1734         .send_len = sizeof(set_bredr_off_param),
1735         .expect_status = MGMT_STATUS_REJECTED,
1736 };
1737
1738 static const struct generic_data set_bredr_off_failure_test_2 = {
1739         .setup_settings = settings_powered,
1740         .send_opcode = MGMT_OP_SET_BREDR,
1741         .send_param = set_bredr_off_param,
1742         .send_len = sizeof(set_bredr_off_param),
1743         .expect_status = MGMT_STATUS_REJECTED,
1744 };
1745
1746 static const struct generic_data set_bredr_off_failure_test_3 = {
1747         .setup_settings = settings_le,
1748         .send_opcode = MGMT_OP_SET_BREDR,
1749         .send_param = set_bredr_invalid_param,
1750         .send_len = sizeof(set_bredr_invalid_param),
1751         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1752 };
1753
1754 static const char set_local_name_param[260] = { 'T', 'e', 's', 't', ' ',
1755                                                 'n', 'a', 'm', 'e' };
1756 static const char write_local_name_hci[248] = { 'T', 'e', 's', 't', ' ',
1757                                                 'n', 'a', 'm', 'e' };
1758 static const char write_eir_local_name_hci_1[241] = { 0x00,
1759                 0x0a, 0x09, 'T', 'e', 's', 't', ' ', 'n', 'a', 'm', 'e',
1760                 0x02, 0x0a, 0x00, };
1761
1762 static const struct generic_data set_local_name_test_1 = {
1763         .send_opcode = MGMT_OP_SET_LOCAL_NAME,
1764         .send_param = set_local_name_param,
1765         .send_len = sizeof(set_local_name_param),
1766         .expect_status = MGMT_STATUS_SUCCESS,
1767         .expect_param = set_local_name_param,
1768         .expect_len = sizeof(set_local_name_param),
1769         .expect_alt_ev = MGMT_EV_LOCAL_NAME_CHANGED,
1770         .expect_alt_ev_param = set_local_name_param,
1771         .expect_alt_ev_len = sizeof(set_local_name_param),
1772 };
1773
1774 static const struct generic_data set_local_name_test_2 = {
1775         .setup_settings = settings_powered,
1776         .send_opcode = MGMT_OP_SET_LOCAL_NAME,
1777         .send_param = set_local_name_param,
1778         .send_len = sizeof(set_local_name_param),
1779         .expect_status = MGMT_STATUS_SUCCESS,
1780         .expect_param = set_local_name_param,
1781         .expect_len = sizeof(set_local_name_param),
1782         .expect_hci_command = BT_HCI_CMD_WRITE_LOCAL_NAME,
1783         .expect_hci_param = write_local_name_hci,
1784         .expect_hci_len = sizeof(write_local_name_hci),
1785         .expect_alt_ev = MGMT_EV_LOCAL_NAME_CHANGED,
1786         .expect_alt_ev_param = set_local_name_param,
1787         .expect_alt_ev_len = sizeof(set_local_name_param),
1788 };
1789
1790 static const struct generic_data set_local_name_test_3 = {
1791         .setup_settings = settings_powered_ssp,
1792         .send_opcode = MGMT_OP_SET_LOCAL_NAME,
1793         .send_param = set_local_name_param,
1794         .send_len = sizeof(set_local_name_param),
1795         .expect_status = MGMT_STATUS_SUCCESS,
1796         .expect_param = set_local_name_param,
1797         .expect_len = sizeof(set_local_name_param),
1798         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
1799         .expect_hci_param = write_eir_local_name_hci_1,
1800         .expect_hci_len = sizeof(write_eir_local_name_hci_1),
1801         .expect_alt_ev = MGMT_EV_LOCAL_NAME_CHANGED,
1802         .expect_alt_ev_param = set_local_name_param,
1803         .expect_alt_ev_len = sizeof(set_local_name_param),
1804 };
1805
1806 static const char start_discovery_invalid_param[] = { 0x00 };
1807 static const char start_discovery_bredr_param[] = { 0x01 };
1808 static const char start_discovery_le_param[] = { 0x06 };
1809 static const char start_discovery_bredrle_param[] = { 0x07 };
1810 static const char start_discovery_valid_hci[] = { 0x01, 0x01 };
1811 static const char start_discovery_evt[] = { 0x07, 0x01 };
1812 static const char start_discovery_le_evt[] = { 0x06, 0x01 };
1813
1814 static const struct generic_data start_discovery_not_powered_test_1 = {
1815         .send_opcode = MGMT_OP_START_DISCOVERY,
1816         .send_param = start_discovery_bredr_param,
1817         .send_len = sizeof(start_discovery_bredr_param),
1818         .expect_status = MGMT_STATUS_NOT_POWERED,
1819         .expect_param = start_discovery_bredr_param,
1820         .expect_len = sizeof(start_discovery_bredr_param),
1821 };
1822
1823 static const struct generic_data start_discovery_invalid_param_test_1 = {
1824         .setup_settings = settings_powered,
1825         .send_opcode = MGMT_OP_START_DISCOVERY,
1826         .send_param = start_discovery_invalid_param,
1827         .send_len = sizeof(start_discovery_invalid_param),
1828         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1829         .expect_param = start_discovery_invalid_param,
1830         .expect_len = sizeof(start_discovery_invalid_param),
1831 };
1832
1833 static const struct generic_data start_discovery_not_supported_test_1 = {
1834         .setup_settings = settings_powered,
1835         .send_opcode = MGMT_OP_START_DISCOVERY,
1836         .send_param = start_discovery_le_param,
1837         .send_len = sizeof(start_discovery_le_param),
1838         .expect_status = MGMT_STATUS_REJECTED,
1839         .expect_param = start_discovery_le_param,
1840         .expect_len = sizeof(start_discovery_le_param),
1841 };
1842
1843 static const struct generic_data start_discovery_valid_param_test_1 = {
1844         .setup_settings = settings_powered_le,
1845         .send_opcode = MGMT_OP_START_DISCOVERY,
1846         .send_param = start_discovery_bredrle_param,
1847         .send_len = sizeof(start_discovery_bredrle_param),
1848         .expect_status = MGMT_STATUS_SUCCESS,
1849         .expect_param = start_discovery_bredrle_param,
1850         .expect_len = sizeof(start_discovery_bredrle_param),
1851         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
1852         .expect_hci_param = start_discovery_valid_hci,
1853         .expect_hci_len = sizeof(start_discovery_valid_hci),
1854         .expect_alt_ev = MGMT_EV_DISCOVERING,
1855         .expect_alt_ev_param = start_discovery_evt,
1856         .expect_alt_ev_len = sizeof(start_discovery_evt),
1857 };
1858
1859 static const struct generic_data start_discovery_valid_param_test_2 = {
1860         .setup_settings = settings_powered,
1861         .send_opcode = MGMT_OP_START_DISCOVERY,
1862         .send_param = start_discovery_le_param,
1863         .send_len = sizeof(start_discovery_le_param),
1864         .expect_status = MGMT_STATUS_SUCCESS,
1865         .expect_param = start_discovery_le_param,
1866         .expect_len = sizeof(start_discovery_le_param),
1867         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
1868         .expect_hci_param = start_discovery_valid_hci,
1869         .expect_hci_len = sizeof(start_discovery_valid_hci),
1870         .expect_alt_ev = MGMT_EV_DISCOVERING,
1871         .expect_alt_ev_param = start_discovery_le_evt,
1872         .expect_alt_ev_len = sizeof(start_discovery_le_evt),
1873 };
1874
1875 static const struct generic_data start_discovery_valid_param_power_off_1 = {
1876         .setup_settings = settings_le,
1877         .send_opcode = MGMT_OP_START_DISCOVERY,
1878         .send_param = start_discovery_bredrle_param,
1879         .send_len = sizeof(start_discovery_bredrle_param),
1880         .expect_status = MGMT_STATUS_NOT_POWERED,
1881         .force_power_off = true,
1882         .expect_param = start_discovery_bredrle_param,
1883         .expect_len = sizeof(start_discovery_bredrle_param),
1884 };
1885
1886 static const char stop_discovery_bredrle_param[] = { 0x07 };
1887 static const char stop_discovery_bredrle_invalid_param[] = { 0x06 };
1888 static const char stop_discovery_valid_hci[] = { 0x00, 0x00 };
1889 static const char stop_discovery_evt[] = { 0x07, 0x00 };
1890 static const char stop_discovery_bredr_param[] = { 0x01 };
1891 static const char stop_discovery_bredr_discovering[] = { 0x01, 0x00 };
1892
1893 static const struct generic_data stop_discovery_success_test_1 = {
1894         .setup_settings = settings_powered_le,
1895         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
1896         .setup_send_param = start_discovery_bredrle_param,
1897         .setup_send_len = sizeof(start_discovery_bredrle_param),
1898         .send_opcode = MGMT_OP_STOP_DISCOVERY,
1899         .send_param = stop_discovery_bredrle_param,
1900         .send_len = sizeof(stop_discovery_bredrle_param),
1901         .expect_status = MGMT_STATUS_SUCCESS,
1902         .expect_param = stop_discovery_bredrle_param,
1903         .expect_len = sizeof(stop_discovery_bredrle_param),
1904         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
1905         .expect_hci_param = stop_discovery_valid_hci,
1906         .expect_hci_len = sizeof(stop_discovery_valid_hci),
1907         .expect_alt_ev = MGMT_EV_DISCOVERING,
1908         .expect_alt_ev_param = stop_discovery_evt,
1909         .expect_alt_ev_len = sizeof(stop_discovery_evt),
1910 };
1911
1912 static const struct generic_data stop_discovery_bredr_success_test_1 = {
1913         .setup_settings = settings_powered,
1914         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
1915         .setup_send_param = start_discovery_bredr_param,
1916         .setup_send_len = sizeof(start_discovery_bredr_param),
1917         .send_opcode = MGMT_OP_STOP_DISCOVERY,
1918         .send_param = stop_discovery_bredr_param,
1919         .send_len = sizeof(stop_discovery_bredr_param),
1920         .expect_status = MGMT_STATUS_SUCCESS,
1921         .expect_param = stop_discovery_bredr_param,
1922         .expect_len = sizeof(stop_discovery_bredr_param),
1923         .expect_hci_command = BT_HCI_CMD_INQUIRY_CANCEL,
1924         .expect_alt_ev = MGMT_EV_DISCOVERING,
1925         .expect_alt_ev_param = stop_discovery_bredr_discovering,
1926         .expect_alt_ev_len = sizeof(stop_discovery_bredr_discovering),
1927 };
1928
1929 static const struct generic_data stop_discovery_rejected_test_1 = {
1930         .setup_settings = settings_powered_le,
1931         .send_opcode = MGMT_OP_STOP_DISCOVERY,
1932         .send_param = stop_discovery_bredrle_param,
1933         .send_len = sizeof(stop_discovery_bredrle_param),
1934         .expect_status = MGMT_STATUS_REJECTED,
1935         .expect_param = stop_discovery_bredrle_param,
1936         .expect_len = sizeof(stop_discovery_bredrle_param),
1937 };
1938
1939 static const struct generic_data stop_discovery_invalid_param_test_1 = {
1940         .setup_settings = settings_powered_le,
1941         .setup_send_opcode = MGMT_OP_START_DISCOVERY,
1942         .setup_send_param = start_discovery_bredrle_param,
1943         .setup_send_len = sizeof(start_discovery_bredrle_param),
1944         .send_opcode = MGMT_OP_STOP_DISCOVERY,
1945         .send_param = stop_discovery_bredrle_invalid_param,
1946         .send_len = sizeof(stop_discovery_bredrle_invalid_param),
1947         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1948         .expect_param = stop_discovery_bredrle_invalid_param,
1949         .expect_len = sizeof(stop_discovery_bredrle_invalid_param),
1950 };
1951
1952 static const char start_service_discovery_invalid_param[] = { 0x00, 0x00, 0x00, 0x00 };
1953 static const char start_service_discovery_invalid_resp[] = { 0x00 };
1954 static const char start_service_discovery_bredr_param[] = { 0x01, 0x00, 0x00, 0x00};
1955 static const char start_service_discovery_bredr_resp[] = { 0x01 };
1956 static const char start_service_discovery_le_param[] = { 0x06, 0x00, 0x01, 0x00,
1957                         0xfa, 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00,
1958                         0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 };
1959 static const char start_service_discovery_le_resp[] = { 0x06 };
1960 static const char start_service_discovery_bredrle_param[] = { 0x07, 0x00, 0x01, 0x00,
1961                         0xfa, 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00,
1962                         0x80, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 };
1963 static const char start_service_discovery_bredrle_resp[] = { 0x07 };
1964 static const char start_service_discovery_valid_hci[] = { 0x01, 0x01 };
1965 static const char start_service_discovery_evt[] = { 0x07, 0x01 };
1966 static const char start_service_discovery_le_evt[] = { 0x06, 0x01 };
1967
1968 static const struct generic_data start_service_discovery_not_powered_test_1 = {
1969         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
1970         .send_param = start_service_discovery_bredr_param,
1971         .send_len = sizeof(start_service_discovery_bredr_param),
1972         .expect_status = MGMT_STATUS_NOT_POWERED,
1973         .expect_param = start_service_discovery_bredr_resp,
1974         .expect_len = sizeof(start_service_discovery_bredr_resp),
1975 };
1976
1977 static const struct generic_data start_service_discovery_invalid_param_test_1 = {
1978         .setup_settings = settings_powered,
1979         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
1980         .send_param = start_service_discovery_invalid_param,
1981         .send_len = sizeof(start_service_discovery_invalid_param),
1982         .expect_status = MGMT_STATUS_INVALID_PARAMS,
1983         .expect_param = start_service_discovery_invalid_resp,
1984         .expect_len = sizeof(start_service_discovery_invalid_resp),
1985 };
1986
1987 static const struct generic_data start_service_discovery_not_supported_test_1 = {
1988         .setup_settings = settings_powered,
1989         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
1990         .send_param = start_service_discovery_le_param,
1991         .send_len = sizeof(start_service_discovery_le_param),
1992         .expect_status = MGMT_STATUS_REJECTED,
1993         .expect_param = start_service_discovery_le_resp,
1994         .expect_len = sizeof(start_service_discovery_le_resp),
1995 };
1996
1997 static const struct generic_data start_service_discovery_valid_param_test_1 = {
1998         .setup_settings = settings_powered_le,
1999         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2000         .send_param = start_service_discovery_bredrle_param,
2001         .send_len = sizeof(start_service_discovery_bredrle_param),
2002         .expect_status = MGMT_STATUS_SUCCESS,
2003         .expect_param = start_service_discovery_bredrle_resp,
2004         .expect_len = sizeof(start_service_discovery_bredrle_resp),
2005         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2006         .expect_hci_param = start_service_discovery_valid_hci,
2007         .expect_hci_len = sizeof(start_service_discovery_valid_hci),
2008         .expect_alt_ev = MGMT_EV_DISCOVERING,
2009         .expect_alt_ev_param = start_service_discovery_evt,
2010         .expect_alt_ev_len = sizeof(start_service_discovery_evt),
2011 };
2012
2013 static const struct generic_data start_service_discovery_valid_param_test_2 = {
2014         .setup_settings = settings_powered,
2015         .send_opcode = MGMT_OP_START_SERVICE_DISCOVERY,
2016         .send_param = start_service_discovery_le_param,
2017         .send_len = sizeof(start_service_discovery_le_param),
2018         .expect_status = MGMT_STATUS_SUCCESS,
2019         .expect_param = start_service_discovery_le_resp,
2020         .expect_len = sizeof(start_service_discovery_le_resp),
2021         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
2022         .expect_hci_param = start_service_discovery_valid_hci,
2023         .expect_hci_len = sizeof(start_service_discovery_valid_hci),
2024         .expect_alt_ev = MGMT_EV_DISCOVERING,
2025         .expect_alt_ev_param = start_service_discovery_le_evt,
2026         .expect_alt_ev_len = sizeof(start_service_discovery_le_evt),
2027 };
2028
2029 static const char set_dev_class_valid_param[] = { 0x01, 0x0c };
2030 static const char set_dev_class_zero_rsp[] = { 0x00, 0x00, 0x00 };
2031 static const char set_dev_class_valid_rsp[] = { 0x0c, 0x01, 0x00 };
2032 static const char set_dev_class_valid_hci[] = { 0x0c, 0x01, 0x00 };
2033 static const char set_dev_class_invalid_param[] = { 0x01, 0x01 };
2034
2035 static const struct generic_data set_dev_class_valid_param_test_1 = {
2036         .send_opcode = MGMT_OP_SET_DEV_CLASS,
2037         .send_param = set_dev_class_valid_param,
2038         .send_len = sizeof(set_dev_class_valid_param),
2039         .expect_status = MGMT_STATUS_SUCCESS,
2040         .expect_param = set_dev_class_zero_rsp,
2041         .expect_len = sizeof(set_dev_class_zero_rsp),
2042 };
2043
2044 static const struct generic_data set_dev_class_valid_param_test_2 = {
2045         .setup_settings = settings_powered,
2046         .send_opcode = MGMT_OP_SET_DEV_CLASS,
2047         .send_param = set_dev_class_valid_param,
2048         .send_len = sizeof(set_dev_class_valid_param),
2049         .expect_status = MGMT_STATUS_SUCCESS,
2050         .expect_param = set_dev_class_valid_rsp,
2051         .expect_len = sizeof(set_dev_class_valid_rsp),
2052         .expect_alt_ev = MGMT_EV_CLASS_OF_DEV_CHANGED,
2053         .expect_alt_ev_param = set_dev_class_valid_rsp,
2054         .expect_alt_ev_len = sizeof(set_dev_class_valid_rsp),
2055         .expect_hci_command = BT_HCI_CMD_WRITE_CLASS_OF_DEV,
2056         .expect_hci_param = set_dev_class_valid_hci,
2057         .expect_hci_len = sizeof(set_dev_class_valid_hci),
2058 };
2059
2060 static const struct generic_data set_dev_class_invalid_param_test_1 = {
2061         .send_opcode = MGMT_OP_SET_DEV_CLASS,
2062         .send_param = set_dev_class_invalid_param,
2063         .send_len = sizeof(set_dev_class_invalid_param),
2064         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2065 };
2066
2067 static const char add_spp_uuid_param[] = {
2068                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2069                         0x00, 0x10, 0x00, 0x00, 0x01, 0x11, 0x00, 0x00,
2070                         0x00 };
2071 static const char add_dun_uuid_param[] = {
2072                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2073                         0x00, 0x10, 0x00, 0x00, 0x03, 0x11, 0x00, 0x00,
2074                         0x00 };
2075 static const char add_sync_uuid_param[] = {
2076                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2077                         0x00, 0x10, 0x00, 0x00, 0x04, 0x11, 0x00, 0x00,
2078                         0x00 };
2079 static const char add_opp_uuid_param[] = {
2080                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2081                         0x00, 0x10, 0x00, 0x00, 0x05, 0x11, 0x00, 0x00,
2082                         0x00 };
2083 static const char write_eir_uuid16_hci[241] = { 0x00,
2084                         0x02, 0x0a, 0x00, 0x03, 0x03, 0x01, 0x11 };
2085 static const char write_eir_multi_uuid16_hci_1[241] = { 0x00,
2086                         0x02, 0x0a, 0x00, 0x09, 0x03, 0x01, 0x11, 0x03,
2087                         0x11, 0x04, 0x11, 0x05, 0x11 };
2088 static const char write_eir_multi_uuid16_hci_2[241] = { 0x00,
2089                         0x02, 0x0a, 0x00, 0xeb, 0x02, 0x00, 0x20, 0x01,
2090                         0x20, 0x02, 0x20, 0x03, 0x20, 0x04, 0x20, 0x05,
2091                         0x20, 0x06, 0x20, 0x07, 0x20, 0x08, 0x20, 0x09,
2092                         0x20, 0x0a, 0x20, 0x0b, 0x20, 0x0c, 0x20, 0x0d,
2093                         0x20, 0x0e, 0x20, 0x0f, 0x20, 0x10, 0x20, 0x11,
2094                         0x20, 0x12, 0x20, 0x13, 0x20, 0x14, 0x20, 0x15,
2095                         0x20, 0x16, 0x20, 0x17, 0x20, 0x18, 0x20, 0x19,
2096                         0x20, 0x1a, 0x20, 0x1b, 0x20, 0x1c, 0x20, 0x1d,
2097                         0x20, 0x1e, 0x20, 0x1f, 0x20, 0x20, 0x20, 0x21,
2098                         0x20, 0x22, 0x20, 0x23, 0x20, 0x24, 0x20, 0x25,
2099                         0x20, 0x26, 0x20, 0x27, 0x20, 0x28, 0x20, 0x29,
2100                         0x20, 0x2a, 0x20, 0x2b, 0x20, 0x2c, 0x20, 0x2d,
2101                         0x20, 0x2e, 0x20, 0x2f, 0x20, 0x30, 0x20, 0x31,
2102                         0x20, 0x32, 0x20, 0x33, 0x20, 0x34, 0x20, 0x35,
2103                         0x20, 0x36, 0x20, 0x37, 0x20, 0x38, 0x20, 0x39,
2104                         0x20, 0x3a, 0x20, 0x3b, 0x20, 0x3c, 0x20, 0x3d,
2105                         0x20, 0x3e, 0x20, 0x3f, 0x20, 0x40, 0x20, 0x41,
2106                         0x20, 0x42, 0x20, 0x43, 0x20, 0x44, 0x20, 0x45,
2107                         0x20, 0x46, 0x20, 0x47, 0x20, 0x48, 0x20, 0x49,
2108                         0x20, 0x4a, 0x20, 0x4b, 0x20, 0x4c, 0x20, 0x4d,
2109                         0x20, 0x4e, 0x20, 0x4f, 0x20, 0x50, 0x20, 0x51,
2110                         0x20, 0x52, 0x20, 0x53, 0x20, 0x54, 0x20, 0x55,
2111                         0x20, 0x56, 0x20, 0x57, 0x20, 0x58, 0x20, 0x59,
2112                         0x20, 0x5a, 0x20, 0x5b, 0x20, 0x5c, 0x20, 0x5d,
2113                         0x20, 0x5e, 0x20, 0x5f, 0x20, 0x60, 0x20, 0x61,
2114                         0x20, 0x62, 0x20, 0x63, 0x20, 0x64, 0x20, 0x65,
2115                         0x20, 0x66, 0x20, 0x67, 0x20, 0x68, 0x20, 0x69,
2116                         0x20, 0x6a, 0x20, 0x6b, 0x20, 0x6c, 0x20, 0x6d,
2117                         0x20, 0x6e, 0x20, 0x6f, 0x20, 0x70, 0x20, 0x71,
2118                         0x20, 0x72, 0x20, 0x73, 0x20, 0x74, 0x20, 0x00 };
2119 static const char add_uuid32_param_1[] = {
2120                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2121                         0x00, 0x10, 0x00, 0x00, 0x78, 0x56, 0x34, 0x12,
2122                         0x00 };
2123 static const char add_uuid32_param_2[] = {
2124                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2125                         0x00, 0x10, 0x00, 0x00, 0xef, 0xcd, 0xbc, 0x9a,
2126                         0x00 };
2127 static const char add_uuid32_param_3[] = {
2128                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2129                         0x00, 0x10, 0x00, 0x00, 0xff, 0xee, 0xdd, 0xcc,
2130                         0x00 };
2131 static const char add_uuid32_param_4[] = {
2132                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
2133                         0x00, 0x10, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44,
2134                         0x00 };
2135 static const char write_eir_uuid32_hci[241] = { 0x00,
2136                         0x02, 0x0a, 0x00, 0x05, 0x05, 0x78, 0x56, 0x34,
2137                         0x12 };
2138 static const char write_eir_uuid32_multi_hci[241] = { 0x00,
2139                         0x02, 0x0a, 0x00, 0x11, 0x05, 0x78, 0x56, 0x34,
2140                         0x12, 0xef, 0xcd, 0xbc, 0x9a, 0xff, 0xee, 0xdd,
2141                         0xcc, 0x11, 0x22, 0x33, 0x44 };
2142 static const char write_eir_uuid32_multi_hci_2[] = { 0x00,
2143                         0x02, 0x0a, 0x00, 0xe9, 0x04, 0xff, 0xff, 0xff,
2144                         0xff, 0xfe, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
2145                         0xff, 0xfc, 0xff, 0xff, 0xff, 0xfb, 0xff, 0xff,
2146                         0xff, 0xfa, 0xff, 0xff, 0xff, 0xf9, 0xff, 0xff,
2147                         0xff, 0xf8, 0xff, 0xff, 0xff, 0xf7, 0xff, 0xff,
2148                         0xff, 0xf6, 0xff, 0xff, 0xff, 0xf5, 0xff, 0xff,
2149                         0xff, 0xf4, 0xff, 0xff, 0xff, 0xf3, 0xff, 0xff,
2150                         0xff, 0xf2, 0xff, 0xff, 0xff, 0xf1, 0xff, 0xff,
2151                         0xff, 0xf0, 0xff, 0xff, 0xff, 0xef, 0xff, 0xff,
2152                         0xff, 0xee, 0xff, 0xff, 0xff, 0xed, 0xff, 0xff,
2153                         0xff, 0xec, 0xff, 0xff, 0xff, 0xeb, 0xff, 0xff,
2154                         0xff, 0xea, 0xff, 0xff, 0xff, 0xe9, 0xff, 0xff,
2155                         0xff, 0xe8, 0xff, 0xff, 0xff, 0xe7, 0xff, 0xff,
2156                         0xff, 0xe6, 0xff, 0xff, 0xff, 0xe5, 0xff, 0xff,
2157                         0xff, 0xe4, 0xff, 0xff, 0xff, 0xe3, 0xff, 0xff,
2158                         0xff, 0xe2, 0xff, 0xff, 0xff, 0xe1, 0xff, 0xff,
2159                         0xff, 0xe0, 0xff, 0xff, 0xff, 0xdf, 0xff, 0xff,
2160                         0xff, 0xde, 0xff, 0xff, 0xff, 0xdd, 0xff, 0xff,
2161                         0xff, 0xdc, 0xff, 0xff, 0xff, 0xdb, 0xff, 0xff,
2162                         0xff, 0xda, 0xff, 0xff, 0xff, 0xd9, 0xff, 0xff,
2163                         0xff, 0xd8, 0xff, 0xff, 0xff, 0xd7, 0xff, 0xff,
2164                         0xff, 0xd6, 0xff, 0xff, 0xff, 0xd5, 0xff, 0xff,
2165                         0xff, 0xd4, 0xff, 0xff, 0xff, 0xd3, 0xff, 0xff,
2166                         0xff, 0xd2, 0xff, 0xff, 0xff, 0xd1, 0xff, 0xff,
2167                         0xff, 0xd0, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff,
2168                         0xff, 0xce, 0xff, 0xff, 0xff, 0xcd, 0xff, 0xff,
2169                         0xff, 0xcc, 0xff, 0xff, 0xff, 0xcb, 0xff, 0xff,
2170                         0xff, 0xca, 0xff, 0xff, 0xff, 0xc9, 0xff, 0xff,
2171                         0xff, 0xc8, 0xff, 0xff, 0xff, 0xc7, 0xff, 0xff,
2172                         0xff, 0xc6, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00 };
2173 static const char add_uuid128_param_1[] = {
2174                         0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
2175                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
2176                         0x00 };
2177 static const char add_uuid128_param_2[] = {
2178                         0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88,
2179                         0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
2180                         0x00 };
2181 static const char write_eir_uuid128_hci[241] = { 0x00,
2182                         0x02, 0x0a, 0x00, 0x11, 0x07, 0x00, 0x11, 0x22,
2183                         0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
2184                         0xbb, 0xcc, 0xdd, 0xee, 0xff };
2185 static const char write_eir_uuid128_multi_hci[241] = { 0x00,
2186                         0x02, 0x0a, 0x00, 0x21, 0x07, 0x00, 0x11, 0x22,
2187                         0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
2188                         0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff, 0xee, 0xdd,
2189                         0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55,
2190                         0x44, 0x33, 0x22, 0x11 };
2191 static const char write_eir_uuid128_multi_hci_2[] = { 0x00,
2192                         0x02, 0x0a, 0x00, 0xe1, 0x07, 0x11, 0x22, 0x33,
2193                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2194                         0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22, 0x33,
2195                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2196                         0xcc, 0xdd, 0xee, 0xff, 0x01, 0x11, 0x22, 0x33,
2197                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2198                         0xcc, 0xdd, 0xee, 0xff, 0x02, 0x11, 0x22, 0x33,
2199                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2200                         0xcc, 0xdd, 0xee, 0xff, 0x03, 0x11, 0x22, 0x33,
2201                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2202                         0xcc, 0xdd, 0xee, 0xff, 0x04, 0x11, 0x22, 0x33,
2203                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2204                         0xcc, 0xdd, 0xee, 0xff, 0x05, 0x11, 0x22, 0x33,
2205                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2206                         0xcc, 0xdd, 0xee, 0xff, 0x06, 0x11, 0x22, 0x33,
2207                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2208                         0xcc, 0xdd, 0xee, 0xff, 0x07, 0x11, 0x22, 0x33,
2209                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2210                         0xcc, 0xdd, 0xee, 0xff, 0x08, 0x11, 0x22, 0x33,
2211                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2212                         0xcc, 0xdd, 0xee, 0xff, 0x09, 0x11, 0x22, 0x33,
2213                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2214                         0xcc, 0xdd, 0xee, 0xff, 0x0a, 0x11, 0x22, 0x33,
2215                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2216                         0xcc, 0xdd, 0xee, 0xff, 0x0b, 0x11, 0x22, 0x33,
2217                         0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb,
2218                         0xcc, 0xdd, 0xee, 0xff, 0x0c, 0xff, 0xee, 0xdd,
2219                         0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55,
2220                         0x44, 0x33, 0x22, 0x11, 0x00, 0x00, 0x00, 0x00,
2221                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
2222 static const char write_eir_uuid_mix_hci[241] = { 0x00,
2223                         0x02, 0x0a, 0x00, 0x05, 0x03, 0x01, 0x11, 0x03,
2224                         0x11, 0x09, 0x05, 0x78, 0x56, 0x34, 0x12, 0xef,
2225                         0xcd, 0xbc, 0x9a, 0x21, 0x07, 0x00, 0x11, 0x22,
2226                         0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
2227                         0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xff, 0xee, 0xdd,
2228                         0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x77, 0x66, 0x55,
2229                         0x44, 0x33, 0x22, 0x11 };
2230
2231 static const struct generic_data add_uuid16_test_1 = {
2232         .setup_settings = settings_powered_ssp,
2233         .send_opcode = MGMT_OP_ADD_UUID,
2234         .send_param = add_spp_uuid_param,
2235         .send_len = sizeof(add_spp_uuid_param),
2236         .expect_status = MGMT_STATUS_SUCCESS,
2237         .expect_param = set_dev_class_zero_rsp,
2238         .expect_len = sizeof(set_dev_class_zero_rsp),
2239         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2240         .expect_hci_param = write_eir_uuid16_hci,
2241         .expect_hci_len = sizeof(write_eir_uuid16_hci),
2242 };
2243
2244 static const struct generic_data add_multi_uuid16_test_1 = {
2245         .send_opcode = MGMT_OP_ADD_UUID,
2246         .send_param = add_opp_uuid_param,
2247         .send_len = sizeof(add_opp_uuid_param),
2248         .expect_status = MGMT_STATUS_SUCCESS,
2249         .expect_param = set_dev_class_zero_rsp,
2250         .expect_len = sizeof(set_dev_class_zero_rsp),
2251         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2252         .expect_hci_param = write_eir_multi_uuid16_hci_1,
2253         .expect_hci_len = sizeof(write_eir_multi_uuid16_hci_1),
2254 };
2255
2256 static const struct generic_data add_multi_uuid16_test_2 = {
2257         .send_opcode = MGMT_OP_ADD_UUID,
2258         .send_param = add_opp_uuid_param,
2259         .send_len = sizeof(add_opp_uuid_param),
2260         .expect_status = MGMT_STATUS_SUCCESS,
2261         .expect_param = set_dev_class_zero_rsp,
2262         .expect_len = sizeof(set_dev_class_zero_rsp),
2263         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2264         .expect_hci_param = write_eir_multi_uuid16_hci_2,
2265         .expect_hci_len = sizeof(write_eir_multi_uuid16_hci_2),
2266 };
2267
2268 static const struct generic_data add_uuid32_test_1 = {
2269         .setup_settings = settings_powered_ssp,
2270         .send_opcode = MGMT_OP_ADD_UUID,
2271         .send_param = add_uuid32_param_1,
2272         .send_len = sizeof(add_uuid32_param_1),
2273         .expect_status = MGMT_STATUS_SUCCESS,
2274         .expect_param = set_dev_class_zero_rsp,
2275         .expect_len = sizeof(set_dev_class_zero_rsp),
2276         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2277         .expect_hci_param = write_eir_uuid32_hci,
2278         .expect_hci_len = sizeof(write_eir_uuid32_hci),
2279 };
2280
2281 static const struct generic_data add_uuid32_multi_test_1 = {
2282         .send_opcode = MGMT_OP_ADD_UUID,
2283         .send_param = add_uuid32_param_4,
2284         .send_len = sizeof(add_uuid32_param_4),
2285         .expect_status = MGMT_STATUS_SUCCESS,
2286         .expect_param = set_dev_class_zero_rsp,
2287         .expect_len = sizeof(set_dev_class_zero_rsp),
2288         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2289         .expect_hci_param = write_eir_uuid32_multi_hci,
2290         .expect_hci_len = sizeof(write_eir_uuid32_multi_hci),
2291 };
2292
2293 static const struct generic_data add_uuid32_multi_test_2 = {
2294         .send_opcode = MGMT_OP_ADD_UUID,
2295         .send_param = add_uuid32_param_4,
2296         .send_len = sizeof(add_uuid32_param_4),
2297         .expect_status = MGMT_STATUS_SUCCESS,
2298         .expect_param = set_dev_class_zero_rsp,
2299         .expect_len = sizeof(set_dev_class_zero_rsp),
2300         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2301         .expect_hci_param = write_eir_uuid32_multi_hci_2,
2302         .expect_hci_len = sizeof(write_eir_uuid32_multi_hci_2),
2303 };
2304
2305 static const struct generic_data add_uuid128_test_1 = {
2306         .setup_settings = settings_powered_ssp,
2307         .send_opcode = MGMT_OP_ADD_UUID,
2308         .send_param = add_uuid128_param_1,
2309         .send_len = sizeof(add_uuid128_param_1),
2310         .expect_status = MGMT_STATUS_SUCCESS,
2311         .expect_param = set_dev_class_zero_rsp,
2312         .expect_len = sizeof(set_dev_class_zero_rsp),
2313         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2314         .expect_hci_param = write_eir_uuid128_hci,
2315         .expect_hci_len = sizeof(write_eir_uuid128_hci),
2316 };
2317
2318 static const struct generic_data add_uuid128_multi_test_1 = {
2319         .send_opcode = MGMT_OP_ADD_UUID,
2320         .send_param = add_uuid128_param_2,
2321         .send_len = sizeof(add_uuid32_param_2),
2322         .expect_status = MGMT_STATUS_SUCCESS,
2323         .expect_param = set_dev_class_zero_rsp,
2324         .expect_len = sizeof(set_dev_class_zero_rsp),
2325         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2326         .expect_hci_param = write_eir_uuid128_multi_hci,
2327         .expect_hci_len = sizeof(write_eir_uuid128_multi_hci),
2328 };
2329
2330 static const struct generic_data add_uuid128_multi_test_2 = {
2331         .send_opcode = MGMT_OP_ADD_UUID,
2332         .send_param = add_uuid128_param_2,
2333         .send_len = sizeof(add_uuid128_param_2),
2334         .expect_status = MGMT_STATUS_SUCCESS,
2335         .expect_param = set_dev_class_zero_rsp,
2336         .expect_len = sizeof(set_dev_class_zero_rsp),
2337         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2338         .expect_hci_param = write_eir_uuid128_multi_hci_2,
2339         .expect_hci_len = sizeof(write_eir_uuid128_multi_hci_2),
2340 };
2341
2342 static const struct generic_data add_uuid_mix_test_1 = {
2343         .send_opcode = MGMT_OP_ADD_UUID,
2344         .send_param = add_uuid128_param_2,
2345         .send_len = sizeof(add_uuid128_param_2),
2346         .expect_status = MGMT_STATUS_SUCCESS,
2347         .expect_param = set_dev_class_zero_rsp,
2348         .expect_len = sizeof(set_dev_class_zero_rsp),
2349         .expect_hci_command = BT_HCI_CMD_WRITE_EXT_INQUIRY_RESPONSE,
2350         .expect_hci_param = write_eir_uuid_mix_hci,
2351         .expect_hci_len = sizeof(write_eir_uuid_mix_hci),
2352 };
2353
2354 static const char load_link_keys_valid_param_1[] = { 0x00, 0x00, 0x00 };
2355 static const char load_link_keys_valid_param_2[] = { 0x01, 0x00, 0x00 };
2356 static const char load_link_keys_invalid_param_1[] = { 0x02, 0x00, 0x00 };
2357 static const char load_link_keys_invalid_param_2[] = { 0x00, 0x01, 0x00 };
2358 /* Invalid bdaddr type */
2359 static const char load_link_keys_invalid_param_3[] = { 0x00, 0x01, 0x00,
2360         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* addr */
2361         0x01,                                           /* addr type */
2362         0x00,                                           /* key type */
2363         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2364         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2365         0x04,                                           /* PIN length */
2366 };
2367
2368 static const struct generic_data load_link_keys_success_test_1 = {
2369         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2370         .send_param = load_link_keys_valid_param_1,
2371         .send_len = sizeof(load_link_keys_valid_param_1),
2372         .expect_status = MGMT_STATUS_SUCCESS,
2373 };
2374
2375 static const struct generic_data load_link_keys_success_test_2 = {
2376         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2377         .send_param = load_link_keys_valid_param_2,
2378         .send_len = sizeof(load_link_keys_valid_param_2),
2379         .expect_status = MGMT_STATUS_SUCCESS,
2380 };
2381
2382 static const struct generic_data load_link_keys_invalid_params_test_1 = {
2383         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2384         .send_param = load_link_keys_invalid_param_1,
2385         .send_len = sizeof(load_link_keys_invalid_param_1),
2386         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2387 };
2388
2389 static const struct generic_data load_link_keys_invalid_params_test_2 = {
2390         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2391         .send_param = load_link_keys_invalid_param_2,
2392         .send_len = sizeof(load_link_keys_invalid_param_2),
2393         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2394 };
2395
2396 static const struct generic_data load_link_keys_invalid_params_test_3 = {
2397         .send_opcode = MGMT_OP_LOAD_LINK_KEYS,
2398         .send_param = load_link_keys_invalid_param_3,
2399         .send_len = sizeof(load_link_keys_invalid_param_3),
2400         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2401 };
2402
2403 static const char load_ltks_valid_param_1[] = { 0x00, 0x00 };
2404 /* Invalid key count */
2405 static const char load_ltks_invalid_param_1[] = { 0x01, 0x00 };
2406 /* Invalid addr type */
2407 static const char load_ltks_invalid_param_2[] = {
2408         0x01, 0x00,                                     /* count */
2409         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2410         0x00,                                           /* addr type */
2411         0x00,                                           /* authenticated */
2412         0x00,                                           /* master */
2413         0x00,                                           /* encryption size */
2414         0x00, 0x00,                                     /* diversifier */
2415         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2416         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2417         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2418 };
2419 /* Invalid master value */
2420 static const char load_ltks_invalid_param_3[] = {
2421         0x01, 0x00,                                     /* count */
2422         0x00, 0x01, 0x02, 0x03, 0x04, 0x05,             /* bdaddr */
2423         0x01,                                           /* addr type */
2424         0x00,                                           /* authenticated */
2425         0x02,                                           /* master */
2426         0x00,                                           /* encryption size */
2427         0x00, 0x00,                                     /* diversifier */
2428         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* rand */
2429         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (1/2) */
2430         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* value (2/2) */
2431 };
2432
2433 static const struct generic_data load_ltks_success_test_1 = {
2434         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2435         .send_param = load_ltks_valid_param_1,
2436         .send_len = sizeof(load_ltks_valid_param_1),
2437         .expect_status = MGMT_STATUS_SUCCESS,
2438 };
2439
2440 static const struct generic_data load_ltks_invalid_params_test_1 = {
2441         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2442         .send_param = load_ltks_invalid_param_1,
2443         .send_len = sizeof(load_ltks_invalid_param_1),
2444         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2445 };
2446
2447 static const struct generic_data load_ltks_invalid_params_test_2 = {
2448         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2449         .send_param = load_ltks_invalid_param_2,
2450         .send_len = sizeof(load_ltks_invalid_param_2),
2451         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2452 };
2453
2454 static const struct generic_data load_ltks_invalid_params_test_3 = {
2455         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2456         .send_param = load_ltks_invalid_param_3,
2457         .send_len = sizeof(load_ltks_invalid_param_3),
2458         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2459 };
2460
2461 static const char load_ltks_invalid_param_4[22] = { 0x1d, 0x07 };
2462 static const struct generic_data load_ltks_invalid_params_test_4 = {
2463         .send_opcode = MGMT_OP_LOAD_LONG_TERM_KEYS,
2464         .send_param = load_ltks_invalid_param_4,
2465         .send_len = sizeof(load_ltks_invalid_param_4),
2466         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2467 };
2468
2469 static const char set_io_cap_invalid_param_1[] = { 0xff };
2470
2471 static const struct generic_data set_io_cap_invalid_param_test_1 = {
2472         .send_opcode = MGMT_OP_SET_IO_CAPABILITY,
2473         .send_param = set_io_cap_invalid_param_1,
2474         .send_len = sizeof(set_io_cap_invalid_param_1),
2475         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2476 };
2477
2478 static const char pair_device_param[] = {
2479                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00 };
2480 static const char pair_device_rsp[] = {
2481                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
2482 static const char pair_device_invalid_param_1[] = {
2483                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff, 0x00 };
2484 static const char pair_device_invalid_param_rsp_1[] = {
2485                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
2486 static const char pair_device_invalid_param_2[] = {
2487                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x05 };
2488 static const char pair_device_invalid_param_rsp_2[] = {
2489                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
2490
2491 static const struct generic_data pair_device_not_powered_test_1 = {
2492         .send_opcode = MGMT_OP_PAIR_DEVICE,
2493         .send_param = pair_device_param,
2494         .send_len = sizeof(pair_device_param),
2495         .expect_status = MGMT_STATUS_NOT_POWERED,
2496         .expect_param = pair_device_rsp,
2497         .expect_len = sizeof(pair_device_rsp),
2498 };
2499
2500 static const struct generic_data pair_device_invalid_param_test_1 = {
2501         .send_opcode = MGMT_OP_PAIR_DEVICE,
2502         .send_param = pair_device_invalid_param_1,
2503         .send_len = sizeof(pair_device_invalid_param_1),
2504         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2505         .expect_param = pair_device_invalid_param_rsp_1,
2506         .expect_len = sizeof(pair_device_invalid_param_rsp_1),
2507 };
2508
2509 static const struct generic_data pair_device_invalid_param_test_2 = {
2510         .send_opcode = MGMT_OP_PAIR_DEVICE,
2511         .send_param = pair_device_invalid_param_2,
2512         .send_len = sizeof(pair_device_invalid_param_2),
2513         .expect_status = MGMT_STATUS_INVALID_PARAMS,
2514         .expect_param = pair_device_invalid_param_rsp_2,
2515         .expect_len = sizeof(pair_device_invalid_param_rsp_2),
2516 };
2517
2518 static const void *pair_device_send_param_func(uint16_t *len)
2519 {
2520         struct test_data *data = tester_get_data();
2521         const struct generic_data *test = data->test_data;
2522         static uint8_t param[8];
2523
2524         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
2525
2526         if (test->addr_type_avail)
2527                 param[6] = test->addr_type;
2528         else if (data->hciemu_type == HCIEMU_TYPE_LE)
2529                 param[6] = 0x01; /* Address type */
2530         else
2531                 param[6] = 0x00; /* Address type */
2532         param[7] = test->io_cap;
2533
2534         *len = sizeof(param);
2535
2536         return param;
2537 }
2538
2539 static const void *pair_device_expect_param_func(uint16_t *len)
2540 {
2541         struct test_data *data = tester_get_data();
2542         const struct generic_data *test = data->test_data;
2543         static uint8_t param[7];
2544
2545         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
2546
2547         if (test->addr_type_avail)
2548                 param[6] = test->addr_type;
2549         else if (data->hciemu_type == HCIEMU_TYPE_LE)
2550                 param[6] = 0x01; /* Address type */
2551         else
2552                 param[6] = 0x00; /* Address type */
2553
2554         *len = sizeof(param);
2555
2556         return param;
2557 }
2558
2559 static uint16_t settings_powered_bondable[] = { MGMT_OP_SET_BONDABLE,
2560                                                 MGMT_OP_SET_POWERED, 0 };
2561 static uint8_t auth_req_param[] = { 0x2a, 0x00 };
2562 static uint8_t pair_device_pin[] = { 0x30, 0x30, 0x30, 0x30 }; /* "0000" */
2563
2564 static const struct generic_data pair_device_success_test_1 = {
2565         .setup_settings = settings_powered_bondable,
2566         .send_opcode = MGMT_OP_PAIR_DEVICE,
2567         .send_func = pair_device_send_param_func,
2568         .expect_status = MGMT_STATUS_SUCCESS,
2569         .expect_func = pair_device_expect_param_func,
2570         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2571         .expect_alt_ev_len = 26,
2572         .expect_hci_command = BT_HCI_CMD_AUTH_REQUESTED,
2573         .expect_hci_param = auth_req_param,
2574         .expect_hci_len = sizeof(auth_req_param),
2575         .pin = pair_device_pin,
2576         .pin_len = sizeof(pair_device_pin),
2577         .client_pin = pair_device_pin,
2578         .client_pin_len = sizeof(pair_device_pin),
2579 };
2580
2581 static uint16_t settings_powered_bondable_linksec[] = { MGMT_OP_SET_BONDABLE,
2582                                                         MGMT_OP_SET_POWERED,
2583                                                         MGMT_OP_SET_LINK_SECURITY,
2584                                                         0 };
2585
2586 static const struct generic_data pair_device_success_test_2 = {
2587         .setup_settings = settings_powered_bondable_linksec,
2588         .send_opcode = MGMT_OP_PAIR_DEVICE,
2589         .send_func = pair_device_send_param_func,
2590         .expect_status = MGMT_STATUS_SUCCESS,
2591         .expect_func = pair_device_expect_param_func,
2592         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2593         .expect_alt_ev_len = 26,
2594         .expect_hci_command = BT_HCI_CMD_AUTH_REQUESTED,
2595         .expect_hci_param = auth_req_param,
2596         .expect_hci_len = sizeof(auth_req_param),
2597         .pin = pair_device_pin,
2598         .pin_len = sizeof(pair_device_pin),
2599         .client_pin = pair_device_pin,
2600         .client_pin_len = sizeof(pair_device_pin),
2601 };
2602
2603 static const struct generic_data pair_device_legacy_nonbondable_1 = {
2604         .setup_settings = settings_powered,
2605         .send_opcode = MGMT_OP_PAIR_DEVICE,
2606         .send_func = pair_device_send_param_func,
2607         .expect_status = MGMT_STATUS_SUCCESS,
2608         .expect_func = pair_device_expect_param_func,
2609         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2610         .expect_alt_ev_len = 26,
2611         .pin = pair_device_pin,
2612         .pin_len = sizeof(pair_device_pin),
2613         .client_pin = pair_device_pin,
2614         .client_pin_len = sizeof(pair_device_pin),
2615 };
2616
2617 static const struct generic_data pair_device_power_off_test_1 = {
2618         .setup_settings = settings_powered_bondable,
2619         .send_opcode = MGMT_OP_PAIR_DEVICE,
2620         .send_func = pair_device_send_param_func,
2621         .force_power_off = true,
2622         .expect_status = MGMT_STATUS_NOT_POWERED,
2623         .expect_func = pair_device_expect_param_func,
2624 };
2625
2626 static const void *client_bdaddr_param_func(uint8_t *len)
2627 {
2628         struct test_data *data = tester_get_data();
2629         static uint8_t bdaddr[6];
2630
2631         memcpy(bdaddr, hciemu_get_client_bdaddr(data->hciemu), 6);
2632
2633         *len = sizeof(bdaddr);
2634
2635         return bdaddr;
2636 }
2637
2638 static const struct generic_data pair_device_not_supported_test_1 = {
2639         .setup_settings = settings_powered_bondable,
2640         .send_opcode = MGMT_OP_PAIR_DEVICE,
2641         .send_func = pair_device_send_param_func,
2642         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
2643         .expect_func = pair_device_expect_param_func,
2644         .addr_type_avail = true,
2645         .addr_type = BDADDR_BREDR,
2646 };
2647
2648 static const struct generic_data pair_device_not_supported_test_2 = {
2649         .setup_settings = settings_powered_bondable,
2650         .send_opcode = MGMT_OP_PAIR_DEVICE,
2651         .send_func = pair_device_send_param_func,
2652         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
2653         .expect_func = pair_device_expect_param_func,
2654         .addr_type_avail = true,
2655         .addr_type = BDADDR_LE_PUBLIC,
2656 };
2657
2658 static uint16_t settings_powered_bondable_le[] = { MGMT_OP_SET_LE,
2659                                                         MGMT_OP_SET_BONDABLE,
2660                                                         MGMT_OP_SET_POWERED,
2661                                                         0 };
2662
2663 static const struct generic_data pair_device_reject_transport_not_enabled_1 = {
2664         .setup_settings = settings_powered_bondable_le,
2665         .setup_nobredr = true,
2666         .send_opcode = MGMT_OP_PAIR_DEVICE,
2667         .send_func = pair_device_send_param_func,
2668         .expect_status = MGMT_STATUS_REJECTED,
2669         .expect_func = pair_device_expect_param_func,
2670         .addr_type_avail = true,
2671         .addr_type = BDADDR_BREDR,
2672 };
2673
2674 static const struct generic_data pair_device_reject_transport_not_enabled_2 = {
2675         .setup_settings = settings_powered_bondable,
2676         .send_opcode = MGMT_OP_PAIR_DEVICE,
2677         .send_func = pair_device_send_param_func,
2678         .expect_status = MGMT_STATUS_REJECTED,
2679         .expect_func = pair_device_expect_param_func,
2680         .addr_type_avail = true,
2681         .addr_type = BDADDR_LE_PUBLIC,
2682 };
2683
2684 static const struct generic_data pair_device_reject_test_1 = {
2685         .setup_settings = settings_powered_bondable,
2686         .send_opcode = MGMT_OP_PAIR_DEVICE,
2687         .send_func = pair_device_send_param_func,
2688         .expect_status = MGMT_STATUS_AUTH_FAILED,
2689         .expect_func = pair_device_expect_param_func,
2690         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
2691         .expect_alt_ev_len = 8,
2692         .expect_hci_command = BT_HCI_CMD_PIN_CODE_REQUEST_NEG_REPLY,
2693         .expect_hci_func = client_bdaddr_param_func,
2694         .expect_pin = true,
2695         .client_pin = pair_device_pin,
2696         .client_pin_len = sizeof(pair_device_pin),
2697 };
2698
2699 static const struct generic_data pair_device_reject_test_2 = {
2700         .setup_settings = settings_powered_bondable,
2701         .send_opcode = MGMT_OP_PAIR_DEVICE,
2702         .send_func = pair_device_send_param_func,
2703         .expect_status = MGMT_STATUS_AUTH_FAILED,
2704         .expect_func = pair_device_expect_param_func,
2705         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
2706         .expect_alt_ev_len = 8,
2707         .expect_hci_command = BT_HCI_CMD_AUTH_REQUESTED,
2708         .expect_hci_param = auth_req_param,
2709         .expect_hci_len = sizeof(auth_req_param),
2710         .pin = pair_device_pin,
2711         .pin_len = sizeof(pair_device_pin),
2712 };
2713
2714 static const struct generic_data pair_device_reject_test_3 = {
2715         .setup_settings = settings_powered_bondable_linksec,
2716         .send_opcode = MGMT_OP_PAIR_DEVICE,
2717         .send_func = pair_device_send_param_func,
2718         .expect_status = MGMT_STATUS_AUTH_FAILED,
2719         .expect_func = pair_device_expect_param_func,
2720         .expect_hci_command = BT_HCI_CMD_PIN_CODE_REQUEST_NEG_REPLY,
2721         .expect_hci_func = client_bdaddr_param_func,
2722         .expect_pin = true,
2723         .client_pin = pair_device_pin,
2724         .client_pin_len = sizeof(pair_device_pin),
2725 };
2726
2727 static const struct generic_data pair_device_reject_test_4 = {
2728         .setup_settings = settings_powered_bondable_linksec,
2729         .send_opcode = MGMT_OP_PAIR_DEVICE,
2730         .send_func = pair_device_send_param_func,
2731         .expect_status = MGMT_STATUS_AUTH_FAILED,
2732         .expect_func = pair_device_expect_param_func,
2733         .pin = pair_device_pin,
2734         .pin_len = sizeof(pair_device_pin),
2735 };
2736
2737 static uint16_t settings_powered_bondable_ssp[] = {     MGMT_OP_SET_BONDABLE,
2738                                                         MGMT_OP_SET_SSP,
2739                                                         MGMT_OP_SET_POWERED,
2740                                                         0 };
2741
2742 static const struct generic_data pair_device_ssp_test_1 = {
2743         .setup_settings = settings_powered_bondable_ssp,
2744         .client_enable_ssp = true,
2745         .send_opcode = MGMT_OP_PAIR_DEVICE,
2746         .send_func = pair_device_send_param_func,
2747         .expect_status = MGMT_STATUS_SUCCESS,
2748         .expect_func = pair_device_expect_param_func,
2749         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2750         .expect_alt_ev_len = 26,
2751         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
2752         .expect_hci_func = client_bdaddr_param_func,
2753         .io_cap = 0x03, /* NoInputNoOutput */
2754         .client_io_cap = 0x03, /* NoInputNoOutput */
2755 };
2756
2757 static const void *client_io_cap_param_func(uint8_t *len)
2758 {
2759         struct test_data *data = tester_get_data();
2760         const struct generic_data *test = data->test_data;
2761         static uint8_t param[9];
2762
2763         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
2764         memcpy(&param[6], test->expect_hci_param, 3);
2765
2766         *len = sizeof(param);
2767
2768         return param;
2769 }
2770
2771 const uint8_t no_bonding_io_cap[] = { 0x03, 0x00, 0x00 };
2772 static const struct generic_data pair_device_ssp_test_2 = {
2773         .setup_settings = settings_powered_ssp,
2774         .client_enable_ssp = true,
2775         .send_opcode = MGMT_OP_PAIR_DEVICE,
2776         .send_func = pair_device_send_param_func,
2777         .expect_status = MGMT_STATUS_SUCCESS,
2778         .expect_func = pair_device_expect_param_func,
2779         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2780         .expect_alt_ev_len = 26,
2781         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
2782         .expect_hci_func = client_io_cap_param_func,
2783         .expect_hci_param = no_bonding_io_cap,
2784         .expect_hci_len = sizeof(no_bonding_io_cap),
2785         .io_cap = 0x03, /* NoInputNoOutput */
2786         .client_io_cap = 0x03, /* NoInputNoOutput */
2787 };
2788
2789 const uint8_t bonding_io_cap[] = { 0x03, 0x00, 0x02 };
2790 static const struct generic_data pair_device_ssp_test_3 = {
2791         .setup_settings = settings_powered_bondable_ssp,
2792         .client_enable_ssp = true,
2793         .send_opcode = MGMT_OP_PAIR_DEVICE,
2794         .send_func = pair_device_send_param_func,
2795         .expect_status = MGMT_STATUS_SUCCESS,
2796         .expect_func = pair_device_expect_param_func,
2797         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2798         .expect_alt_ev_len = 26,
2799         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
2800         .expect_hci_func = client_io_cap_param_func,
2801         .expect_hci_param = bonding_io_cap,
2802         .expect_hci_len = sizeof(bonding_io_cap),
2803         .io_cap = 0x03, /* NoInputNoOutput */
2804         .client_io_cap = 0x03, /* NoInputNoOutput */
2805 };
2806
2807 static const struct generic_data pair_device_ssp_test_4 = {
2808         .setup_settings = settings_powered_bondable_ssp,
2809         .client_enable_ssp = true,
2810         .send_opcode = MGMT_OP_PAIR_DEVICE,
2811         .send_func = pair_device_send_param_func,
2812         .expect_status = MGMT_STATUS_SUCCESS,
2813         .expect_func = pair_device_expect_param_func,
2814         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2815         .expect_alt_ev_len = 26,
2816         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
2817         .expect_hci_func = client_bdaddr_param_func,
2818         .io_cap = 0x01, /* DisplayYesNo */
2819         .client_io_cap = 0x01, /* DisplayYesNo */
2820 };
2821
2822 const uint8_t mitm_no_bonding_io_cap[] = { 0x01, 0x00, 0x01 };
2823 static const struct generic_data pair_device_ssp_test_5 = {
2824         .setup_settings = settings_powered_ssp,
2825         .client_enable_ssp = true,
2826         .send_opcode = MGMT_OP_PAIR_DEVICE,
2827         .send_func = pair_device_send_param_func,
2828         .expect_status = MGMT_STATUS_SUCCESS,
2829         .expect_func = pair_device_expect_param_func,
2830         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2831         .expect_alt_ev_len = 26,
2832         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
2833         .expect_hci_func = client_io_cap_param_func,
2834         .expect_hci_param = mitm_no_bonding_io_cap,
2835         .expect_hci_len = sizeof(mitm_no_bonding_io_cap),
2836         .io_cap = 0x01, /* DisplayYesNo */
2837         .client_io_cap = 0x01, /* DisplayYesNo */
2838 };
2839
2840 const uint8_t mitm_bonding_io_cap[] = { 0x01, 0x00, 0x03 };
2841 static const struct generic_data pair_device_ssp_test_6 = {
2842         .setup_settings = settings_powered_bondable_ssp,
2843         .client_enable_ssp = true,
2844         .send_opcode = MGMT_OP_PAIR_DEVICE,
2845         .send_func = pair_device_send_param_func,
2846         .expect_status = MGMT_STATUS_SUCCESS,
2847         .expect_func = pair_device_expect_param_func,
2848         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2849         .expect_alt_ev_len = 26,
2850         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_REPLY,
2851         .expect_hci_func = client_io_cap_param_func,
2852         .expect_hci_param = mitm_bonding_io_cap,
2853         .expect_hci_len = sizeof(mitm_bonding_io_cap),
2854         .io_cap = 0x01, /* DisplayYesNo */
2855         .client_io_cap = 0x01, /* DisplayYesNo */
2856 };
2857
2858 static const struct generic_data pair_device_ssp_reject_1 = {
2859         .setup_settings = settings_powered_bondable_ssp,
2860         .client_enable_ssp = true,
2861         .send_opcode = MGMT_OP_PAIR_DEVICE,
2862         .send_func = pair_device_send_param_func,
2863         .expect_status = MGMT_STATUS_AUTH_FAILED,
2864         .expect_func = pair_device_expect_param_func,
2865         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
2866         .expect_alt_ev_len = 8,
2867         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_NEG_REPLY,
2868         .expect_hci_func = client_bdaddr_param_func,
2869         .io_cap = 0x01, /* DisplayYesNo */
2870         .client_io_cap = 0x01, /* DisplayYesNo */
2871         .client_auth_req = 0x01, /* No Bonding - MITM */
2872         .reject_confirm = true,
2873 };
2874
2875 static const struct generic_data pair_device_ssp_reject_2 = {
2876         .setup_settings = settings_powered_bondable_ssp,
2877         .client_enable_ssp = true,
2878         .send_opcode = MGMT_OP_PAIR_DEVICE,
2879         .send_func = pair_device_send_param_func,
2880         .expect_status = MGMT_STATUS_AUTH_FAILED,
2881         .expect_func = pair_device_expect_param_func,
2882         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
2883         .expect_alt_ev_len = 8,
2884         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
2885         .expect_hci_func = client_bdaddr_param_func,
2886         .io_cap = 0x01, /* DisplayYesNo */
2887         .client_io_cap = 0x01, /* DisplayYesNo */
2888         .client_reject_confirm = true,
2889 };
2890
2891 static const struct generic_data pair_device_ssp_nonbondable_1 = {
2892         .setup_settings = settings_powered_ssp,
2893         .client_enable_ssp = true,
2894         .send_opcode = MGMT_OP_PAIR_DEVICE,
2895         .send_func = pair_device_send_param_func,
2896         .expect_status = MGMT_STATUS_SUCCESS,
2897         .expect_func = pair_device_expect_param_func,
2898         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
2899         .expect_alt_ev_len = 26,
2900         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
2901         .expect_hci_func = client_bdaddr_param_func,
2902         .io_cap = 0x01, /* DisplayYesNo */
2903         .client_io_cap = 0x01, /* DisplayYesNo */
2904 };
2905
2906 static const struct generic_data pair_device_le_success_test_1 = {
2907         .setup_settings = settings_powered_bondable,
2908         .send_opcode = MGMT_OP_PAIR_DEVICE,
2909         .send_func = pair_device_send_param_func,
2910         .just_works = true,
2911         .expect_status = MGMT_STATUS_SUCCESS,
2912         .expect_func = pair_device_expect_param_func,
2913         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
2914         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
2915 };
2916
2917 static bool ltk_is_authenticated(const struct mgmt_ltk_info *ltk)
2918 {
2919         switch (ltk->type) {
2920         case 0x01:
2921         case 0x03:
2922                 return true;
2923         default:
2924                 return false;
2925         }
2926 }
2927
2928 static bool ltk_is_sc(const struct mgmt_ltk_info *ltk)
2929 {
2930         switch (ltk->type) {
2931         case 0x02:
2932         case 0x03:
2933         case 0x04:
2934                 return true;
2935         default:
2936                 return false;
2937         }
2938 }
2939
2940 static bool verify_ltk(const void *param, uint16_t length)
2941 {
2942         struct test_data *data = tester_get_data();
2943         const struct generic_data *test = data->test_data;
2944         const struct mgmt_ev_new_long_term_key *ev = param;
2945
2946         if (length != sizeof(struct mgmt_ev_new_long_term_key)) {
2947                 tester_warn("Invalid new ltk length %u != %zu", length,
2948                                 sizeof(struct mgmt_ev_new_long_term_key));
2949                 return false;
2950         }
2951
2952         if (test->just_works && ltk_is_authenticated(&ev->key)) {
2953                 tester_warn("Authenticated key for just-works");
2954                 return false;
2955         }
2956
2957         if (!test->just_works && !ltk_is_authenticated(&ev->key)) {
2958                 tester_warn("Unauthenticated key for MITM");
2959                 return false;
2960         }
2961
2962         if (test->expect_sc_key && !ltk_is_sc(&ev->key)) {
2963                 tester_warn("Non-LE SC key for SC pairing");
2964                 return false;
2965         }
2966
2967         if (!test->expect_sc_key && ltk_is_sc(&ev->key)) {
2968                 tester_warn("SC key for Non-SC pairing");
2969                 return false;
2970         }
2971
2972         return true;
2973 }
2974
2975 static const struct generic_data pair_device_le_success_test_2 = {
2976         .setup_settings = settings_powered_bondable,
2977         .io_cap = 0x02, /* KeyboardOnly */
2978         .client_io_cap = 0x04, /* KeyboardDisplay */
2979         .send_opcode = MGMT_OP_PAIR_DEVICE,
2980         .send_func = pair_device_send_param_func,
2981         .expect_status = MGMT_STATUS_SUCCESS,
2982         .expect_func = pair_device_expect_param_func,
2983         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
2984         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
2985         .verify_alt_ev_func = verify_ltk,
2986 };
2987
2988 static uint16_t settings_powered_sc_bondable_le_ssp[] = {
2989                                                 MGMT_OP_SET_BONDABLE,
2990                                                 MGMT_OP_SET_LE,
2991                                                 MGMT_OP_SET_SSP,
2992                                                 MGMT_OP_SET_SECURE_CONN,
2993                                                 MGMT_OP_SET_POWERED,
2994                                                 0 };
2995
2996 static const struct generic_data pair_device_smp_bredr_test_1 = {
2997         .setup_settings = settings_powered_sc_bondable_le_ssp,
2998         .client_enable_ssp = true,
2999         .client_enable_le = true,
3000         .client_enable_sc = true,
3001         .expect_sc_key = true,
3002         .just_works = true,
3003         .send_opcode = MGMT_OP_PAIR_DEVICE,
3004         .send_func = pair_device_send_param_func,
3005         .expect_status = MGMT_STATUS_SUCCESS,
3006         .expect_func = pair_device_expect_param_func,
3007         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3008         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3009         .verify_alt_ev_func = verify_ltk,
3010         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3011         .expect_hci_func = client_bdaddr_param_func,
3012         .io_cap = 0x03, /* NoInputNoOutput */
3013         .client_io_cap = 0x03, /* NoInputNoOutput */
3014 };
3015
3016 static const struct generic_data pair_device_smp_bredr_test_2 = {
3017         .setup_settings = settings_powered_sc_bondable_le_ssp,
3018         .client_enable_ssp = true,
3019         .client_enable_le = true,
3020         .client_enable_sc = true,
3021         .expect_sc_key = true,
3022         .send_opcode = MGMT_OP_PAIR_DEVICE,
3023         .send_func = pair_device_send_param_func,
3024         .expect_status = MGMT_STATUS_SUCCESS,
3025         .expect_func = pair_device_expect_param_func,
3026         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3027         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3028         .verify_alt_ev_func = verify_ltk,
3029         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3030         .expect_hci_func = client_bdaddr_param_func,
3031         .io_cap = 0x01, /* DisplayYesNo */
3032         .client_io_cap = 0x01, /* DisplayYesNo */
3033 };
3034
3035 static const struct generic_data pair_device_le_reject_test_1 = {
3036         .setup_settings = settings_powered_bondable,
3037         .io_cap = 0x02, /* KeyboardOnly */
3038         .client_io_cap = 0x04, /* KeyboardDisplay */
3039         .send_opcode = MGMT_OP_PAIR_DEVICE,
3040         .send_func = pair_device_send_param_func,
3041         .expect_status = MGMT_STATUS_AUTH_FAILED,
3042         .expect_func = pair_device_expect_param_func,
3043         .expect_alt_ev =  MGMT_EV_AUTH_FAILED,
3044         .expect_alt_ev_len = sizeof(struct mgmt_ev_auth_failed),
3045         .reject_confirm = true,
3046 };
3047
3048 static uint16_t settings_powered_sc_bondable[] = { MGMT_OP_SET_BONDABLE,
3049                                                 MGMT_OP_SET_SECURE_CONN,
3050                                                 MGMT_OP_SET_POWERED, 0 };
3051
3052 static const struct generic_data pair_device_le_sc_legacy_test_1 = {
3053         .setup_settings = settings_powered_sc_bondable,
3054         .send_opcode = MGMT_OP_PAIR_DEVICE,
3055         .send_func = pair_device_send_param_func,
3056         .just_works = true,
3057         .expect_status = MGMT_STATUS_SUCCESS,
3058         .expect_func = pair_device_expect_param_func,
3059         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3060         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3061         .verify_alt_ev_func = verify_ltk,
3062 };
3063
3064 static const struct generic_data pair_device_le_sc_success_test_1 = {
3065         .setup_settings = settings_powered_sc_bondable,
3066         .send_opcode = MGMT_OP_PAIR_DEVICE,
3067         .send_func = pair_device_send_param_func,
3068         .just_works = true,
3069         .client_enable_sc = true,
3070         .expect_sc_key = true,
3071         .expect_status = MGMT_STATUS_SUCCESS,
3072         .expect_func = pair_device_expect_param_func,
3073         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3074         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3075         .verify_alt_ev_func = verify_ltk,
3076 };
3077
3078 static const struct generic_data pair_device_le_sc_success_test_2 = {
3079         .setup_settings = settings_powered_sc_bondable,
3080         .send_opcode = MGMT_OP_PAIR_DEVICE,
3081         .send_func = pair_device_send_param_func,
3082         .client_enable_sc = true,
3083         .expect_sc_key = true,
3084         .io_cap = 0x02, /* KeyboardOnly */
3085         .client_io_cap = 0x02, /* KeyboardOnly */
3086         .expect_status = MGMT_STATUS_SUCCESS,
3087         .expect_func = pair_device_expect_param_func,
3088         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3089         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3090         .verify_alt_ev_func = verify_ltk,
3091 };
3092
3093 static uint16_t settings_powered_connectable_bondable[] = {
3094                                                 MGMT_OP_SET_BONDABLE,
3095                                                 MGMT_OP_SET_CONNECTABLE,
3096                                                 MGMT_OP_SET_POWERED, 0 };
3097
3098 static const struct generic_data pairing_acceptor_legacy_1 = {
3099         .setup_settings = settings_powered_connectable_bondable,
3100         .pin = pair_device_pin,
3101         .pin_len = sizeof(pair_device_pin),
3102         .client_pin = pair_device_pin,
3103         .client_pin_len = sizeof(pair_device_pin),
3104         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3105         .expect_alt_ev_len = 26,
3106 };
3107
3108 static const struct generic_data pairing_acceptor_legacy_2 = {
3109         .setup_settings = settings_powered_connectable_bondable,
3110         .expect_pin = true,
3111         .client_pin = pair_device_pin,
3112         .client_pin_len = sizeof(pair_device_pin),
3113         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3114         .expect_alt_ev_len = 8,
3115 };
3116
3117 static const struct generic_data pairing_acceptor_legacy_3 = {
3118         .setup_settings = settings_powered_connectable,
3119         .client_pin = pair_device_pin,
3120         .client_pin_len = sizeof(pair_device_pin),
3121         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3122         .expect_alt_ev_len = 8,
3123         .expect_hci_command = BT_HCI_CMD_PIN_CODE_REQUEST_NEG_REPLY,
3124         .expect_hci_func = client_bdaddr_param_func,
3125 };
3126
3127 static uint16_t settings_powered_connectable_bondable_linksec[] = {
3128                                                 MGMT_OP_SET_BONDABLE,
3129                                                 MGMT_OP_SET_CONNECTABLE,
3130                                                 MGMT_OP_SET_LINK_SECURITY,
3131                                                 MGMT_OP_SET_POWERED, 0 };
3132
3133 static const struct generic_data pairing_acceptor_linksec_1 = {
3134         .setup_settings = settings_powered_connectable_bondable_linksec,
3135         .pin = pair_device_pin,
3136         .pin_len = sizeof(pair_device_pin),
3137         .client_pin = pair_device_pin,
3138         .client_pin_len = sizeof(pair_device_pin),
3139         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3140         .expect_alt_ev_len = 26,
3141 };
3142
3143 static const struct generic_data pairing_acceptor_linksec_2 = {
3144         .setup_settings = settings_powered_connectable_bondable_linksec,
3145         .expect_pin = true,
3146         .client_pin = pair_device_pin,
3147         .client_pin_len = sizeof(pair_device_pin),
3148         .expect_alt_ev = MGMT_EV_CONNECT_FAILED,
3149         .expect_alt_ev_len = 8,
3150 };
3151
3152 static uint16_t settings_powered_connectable_bondable_ssp[] = {
3153                                                 MGMT_OP_SET_BONDABLE,
3154                                                 MGMT_OP_SET_CONNECTABLE,
3155                                                 MGMT_OP_SET_SSP,
3156                                                 MGMT_OP_SET_POWERED, 0 };
3157
3158 static const struct generic_data pairing_acceptor_ssp_1 = {
3159         .setup_settings = settings_powered_connectable_bondable_ssp,
3160         .client_enable_ssp = true,
3161         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3162         .expect_alt_ev_len = 26,
3163         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3164         .expect_hci_func = client_bdaddr_param_func,
3165         .io_cap = 0x03, /* NoInputNoOutput */
3166         .client_io_cap = 0x03, /* NoInputNoOutput */
3167         .just_works = true,
3168 };
3169
3170 static const struct generic_data pairing_acceptor_ssp_2 = {
3171         .setup_settings = settings_powered_connectable_bondable_ssp,
3172         .client_enable_ssp = true,
3173         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3174         .expect_alt_ev_len = 26,
3175         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3176         .expect_hci_func = client_bdaddr_param_func,
3177         .io_cap = 0x01, /* DisplayYesNo */
3178         .client_io_cap = 0x01, /* DisplayYesNo */
3179 };
3180
3181 static const struct generic_data pairing_acceptor_ssp_3 = {
3182         .setup_settings = settings_powered_connectable_bondable_ssp,
3183         .client_enable_ssp = true,
3184         .expect_alt_ev = MGMT_EV_NEW_LINK_KEY,
3185         .expect_alt_ev_len = 26,
3186         .expect_hci_command = BT_HCI_CMD_USER_CONFIRM_REQUEST_REPLY,
3187         .expect_hci_func = client_bdaddr_param_func,
3188         .io_cap = 0x01, /* DisplayYesNo */
3189         .client_io_cap = 0x01, /* DisplayYesNo */
3190         .just_works = true,
3191 };
3192
3193 static const void *client_io_cap_reject_param_func(uint8_t *len)
3194 {
3195         struct test_data *data = tester_get_data();
3196         static uint8_t param[7];
3197
3198         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3199         param[6] = 0x18; /* Pairing Not Allowed */
3200
3201         *len = sizeof(param);
3202
3203         return param;
3204 }
3205
3206 static uint16_t settings_powered_connectable_ssp[] = {
3207                                                 MGMT_OP_SET_CONNECTABLE,
3208                                                 MGMT_OP_SET_SSP,
3209                                                 MGMT_OP_SET_POWERED, 0 };
3210
3211 static const struct generic_data pairing_acceptor_ssp_4 = {
3212         .setup_settings = settings_powered_connectable_ssp,
3213         .client_enable_ssp = true,
3214         .expect_alt_ev = MGMT_EV_AUTH_FAILED,
3215         .expect_alt_ev_len = 8,
3216         .expect_hci_command = BT_HCI_CMD_IO_CAPABILITY_REQUEST_NEG_REPLY,
3217         .expect_hci_func = client_io_cap_reject_param_func,
3218         .io_cap = 0x01, /* DisplayYesNo */
3219         .client_io_cap = 0x01, /* DisplayYesNo */
3220         .client_auth_req = 0x02, /* Dedicated Bonding - No MITM */
3221 };
3222
3223 static uint16_t settings_powered_sc_bondable_connectable_le_ssp[] = {
3224                                                 MGMT_OP_SET_BONDABLE,
3225                                                 MGMT_OP_SET_CONNECTABLE,
3226                                                 MGMT_OP_SET_LE,
3227                                                 MGMT_OP_SET_SSP,
3228                                                 MGMT_OP_SET_SECURE_CONN,
3229                                                 MGMT_OP_SET_POWERED,
3230                                                 0 };
3231
3232 static const struct generic_data pairing_acceptor_smp_bredr_1 = {
3233         .setup_settings = settings_powered_sc_bondable_connectable_le_ssp,
3234         .client_enable_ssp = true,
3235         .client_enable_le = true,
3236         .client_enable_sc = true,
3237         .expect_sc_key = true,
3238         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3239         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3240         .verify_alt_ev_func = verify_ltk,
3241         .just_works = true,
3242         .io_cap = 0x03, /* NoInputNoOutput */
3243         .client_io_cap = 0x03, /* No InputNoOutput */
3244         .client_auth_req = 0x00, /* No Bonding - No MITM */
3245 };
3246
3247 static const struct generic_data pairing_acceptor_smp_bredr_2 = {
3248         .setup_settings = settings_powered_sc_bondable_connectable_le_ssp,
3249         .client_enable_ssp = true,
3250         .client_enable_le = true,
3251         .client_enable_sc = true,
3252         .expect_sc_key = true,
3253         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3254         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3255         .verify_alt_ev_func = verify_ltk,
3256         .io_cap = 0x01, /* DisplayYesNo */
3257         .client_io_cap = 0x01, /* DisplayYesNo */
3258         .client_auth_req = 0x02, /* Dedicated Bonding - No MITM */
3259 };
3260
3261 static uint16_t settings_powered_bondable_connectable_advertising[] = {
3262                                         MGMT_OP_SET_BONDABLE,
3263                                         MGMT_OP_SET_CONNECTABLE,
3264                                         MGMT_OP_SET_ADVERTISING,
3265                                         MGMT_OP_SET_POWERED, 0 };
3266
3267 static const struct generic_data pairing_acceptor_le_1 = {
3268         .setup_settings = settings_powered_bondable_connectable_advertising,
3269         .io_cap = 0x03, /* NoInputNoOutput */
3270         .client_io_cap = 0x03, /* NoInputNoOutput */
3271         .just_works = true,
3272         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3273         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3274         .verify_alt_ev_func = verify_ltk,
3275 };
3276
3277 static const struct generic_data pairing_acceptor_le_2 = {
3278         .setup_settings = settings_powered_bondable_connectable_advertising,
3279         .io_cap = 0x04, /* KeyboardDisplay */
3280         .client_io_cap = 0x04, /* KeyboardDisplay */
3281         .client_auth_req = 0x05, /* Bonding - MITM */
3282         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3283         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3284         .verify_alt_ev_func = verify_ltk,
3285 };
3286
3287 static const struct generic_data pairing_acceptor_le_3 = {
3288         .setup_settings = settings_powered_bondable_connectable_advertising,
3289         .io_cap = 0x04, /* KeyboardDisplay */
3290         .client_io_cap = 0x04, /* KeyboardDisplay */
3291         .expect_alt_ev =  MGMT_EV_AUTH_FAILED,
3292         .expect_alt_ev_len = sizeof(struct mgmt_ev_auth_failed),
3293         .reject_confirm = true,
3294 };
3295
3296 static const struct generic_data pairing_acceptor_le_4 = {
3297         .setup_settings = settings_powered_bondable_connectable_advertising,
3298         .io_cap = 0x02, /* KeyboardOnly */
3299         .client_io_cap = 0x04, /* KeyboardDisplay */
3300         .client_auth_req = 0x05, /* Bonding - MITM */
3301         .expect_alt_ev =  MGMT_EV_NEW_LONG_TERM_KEY,
3302         .expect_alt_ev_len = sizeof(struct mgmt_ev_new_long_term_key),
3303         .verify_alt_ev_func = verify_ltk,
3304 };
3305
3306 static const struct generic_data pairing_acceptor_le_5 = {
3307         .setup_settings = settings_powered_bondable_connectable_advertising,
3308         .io_cap = 0x02, /* KeyboardOnly */
3309         .client_io_cap = 0x04, /* KeyboardDisplay */
3310         .client_auth_req = 0x05, /* Bonding - MITM */
3311         .reject_confirm = true,
3312         .expect_alt_ev =  MGMT_EV_AUTH_FAILED,
3313         .expect_alt_ev_len = sizeof(struct mgmt_ev_auth_failed),
3314 };
3315
3316 static const char unpair_device_param[] = {
3317                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x00 };
3318 static const char unpair_device_rsp[] = {
3319                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
3320 static const char unpair_device_invalid_param_1[] = {
3321                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff, 0x00 };
3322 static const char unpair_device_invalid_param_rsp_1[] = {
3323                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3324 static const char unpair_device_invalid_param_2[] = {
3325                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00, 0x02 };
3326 static const char unpair_device_invalid_param_rsp_2[] = {
3327                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x00 };
3328
3329 static const struct generic_data unpair_device_not_powered_test_1 = {
3330         .send_opcode = MGMT_OP_UNPAIR_DEVICE,
3331         .send_param = unpair_device_param,
3332         .send_len = sizeof(unpair_device_param),
3333         .expect_status = MGMT_STATUS_NOT_POWERED,
3334         .expect_param = unpair_device_rsp,
3335         .expect_len = sizeof(unpair_device_rsp),
3336 };
3337
3338 static const struct generic_data unpair_device_invalid_param_test_1 = {
3339         .send_opcode = MGMT_OP_UNPAIR_DEVICE,
3340         .send_param = unpair_device_invalid_param_1,
3341         .send_len = sizeof(unpair_device_invalid_param_1),
3342         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3343         .expect_param = unpair_device_invalid_param_rsp_1,
3344         .expect_len = sizeof(unpair_device_invalid_param_rsp_1),
3345 };
3346
3347 static const struct generic_data unpair_device_invalid_param_test_2 = {
3348         .send_opcode = MGMT_OP_UNPAIR_DEVICE,
3349         .send_param = unpair_device_invalid_param_2,
3350         .send_len = sizeof(unpair_device_invalid_param_2),
3351         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3352         .expect_param = unpair_device_invalid_param_rsp_2,
3353         .expect_len = sizeof(unpair_device_invalid_param_rsp_2),
3354 };
3355
3356 static const char disconnect_invalid_param_1[] = {
3357                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3358 static const char disconnect_invalid_param_rsp_1[] = {
3359                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3360
3361 static const struct generic_data disconnect_invalid_param_test_1 = {
3362         .send_opcode = MGMT_OP_DISCONNECT,
3363         .send_param = disconnect_invalid_param_1,
3364         .send_len = sizeof(disconnect_invalid_param_1),
3365         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3366         .expect_param = disconnect_invalid_param_rsp_1,
3367         .expect_len = sizeof(disconnect_invalid_param_rsp_1),
3368 };
3369
3370 static const char block_device_invalid_param_1[] = {
3371                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3372 static const char block_device_invalid_param_rsp_1[] = {
3373                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3374
3375 static const struct generic_data block_device_invalid_param_test_1 = {
3376         .send_opcode = MGMT_OP_BLOCK_DEVICE,
3377         .send_param = block_device_invalid_param_1,
3378         .send_len = sizeof(block_device_invalid_param_1),
3379         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3380         .expect_param = block_device_invalid_param_rsp_1,
3381         .expect_len = sizeof(block_device_invalid_param_rsp_1),
3382 };
3383
3384 static const char unblock_device_invalid_param_1[] = {
3385                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3386 static const char unblock_device_invalid_param_rsp_1[] = {
3387                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xff };
3388
3389 static const struct generic_data unblock_device_invalid_param_test_1 = {
3390         .send_opcode = MGMT_OP_UNBLOCK_DEVICE,
3391         .send_param = unblock_device_invalid_param_1,
3392         .send_len = sizeof(unblock_device_invalid_param_1),
3393         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3394         .expect_param = unblock_device_invalid_param_rsp_1,
3395         .expect_len = sizeof(unblock_device_invalid_param_rsp_1),
3396 };
3397
3398 static const char set_static_addr_valid_param[] = {
3399                         0x11, 0x22, 0x33, 0x44, 0x55, 0xc0 };
3400 static const char set_static_addr_settings[] = { 0x00, 0x82, 0x00, 0x00 };
3401
3402 static const struct generic_data set_static_addr_success_test = {
3403         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
3404         .send_param = set_static_addr_valid_param,
3405         .send_len = sizeof(set_static_addr_valid_param),
3406         .expect_status = MGMT_STATUS_SUCCESS,
3407         .expect_param = set_static_addr_settings,
3408         .expect_len = sizeof(set_static_addr_settings),
3409         .expect_settings_set = MGMT_SETTING_STATIC_ADDRESS,
3410 };
3411
3412 static const char set_static_addr_settings_dual[] = { 0x80, 0x00, 0x00, 0x00 };
3413
3414 static const struct generic_data set_static_addr_success_test_2 = {
3415         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
3416         .send_param = set_static_addr_valid_param,
3417         .send_len = sizeof(set_static_addr_valid_param),
3418         .expect_status = MGMT_STATUS_SUCCESS,
3419         .expect_param = set_static_addr_settings_dual,
3420         .expect_len = sizeof(set_static_addr_settings_dual),
3421 };
3422
3423 static const struct generic_data set_static_addr_failure_test = {
3424         .setup_settings = settings_powered,
3425         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
3426         .send_param = set_static_addr_valid_param,
3427         .send_len = sizeof(set_static_addr_valid_param),
3428         .expect_status = MGMT_STATUS_REJECTED,
3429 };
3430
3431 static const struct generic_data set_static_addr_failure_test_2 = {
3432         .setup_settings = settings_powered,
3433         .send_opcode = MGMT_OP_SET_STATIC_ADDRESS,
3434         .send_param = set_static_addr_valid_param,
3435         .send_len = sizeof(set_static_addr_valid_param),
3436         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
3437 };
3438
3439 static const char set_scan_params_valid_param[] = { 0x60, 0x00, 0x30, 0x00 };
3440
3441 static const struct generic_data set_scan_params_success_test = {
3442         .send_opcode = MGMT_OP_SET_SCAN_PARAMS,
3443         .send_param = set_scan_params_valid_param,
3444         .send_len = sizeof(set_scan_params_valid_param),
3445         .expect_status = MGMT_STATUS_SUCCESS,
3446 };
3447
3448 static const char load_irks_empty_list[] = { 0x00, 0x00 };
3449
3450 static const struct generic_data load_irks_success1_test = {
3451         .send_opcode = MGMT_OP_LOAD_IRKS,
3452         .send_param = load_irks_empty_list,
3453         .send_len = sizeof(load_irks_empty_list),
3454         .expect_status = MGMT_STATUS_SUCCESS,
3455 };
3456
3457 static const char load_irks_one_irk[] = { 0x01, 0x00,
3458                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x01,
3459                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
3460                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
3461
3462 static const struct generic_data load_irks_success2_test = {
3463         .send_opcode = MGMT_OP_LOAD_IRKS,
3464         .send_param = load_irks_one_irk,
3465         .send_len = sizeof(load_irks_one_irk),
3466         .expect_status = MGMT_STATUS_SUCCESS,
3467 };
3468
3469 static const char load_irks_nval_addr_type[] = { 0x01, 0x00,
3470                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00,
3471                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
3472                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
3473
3474 static const struct generic_data load_irks_nval_param1_test = {
3475         .send_opcode = MGMT_OP_LOAD_IRKS,
3476         .send_param = load_irks_nval_addr_type,
3477         .send_len = sizeof(load_irks_nval_addr_type),
3478         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3479 };
3480
3481 static const char load_irks_nval_rand_addr[] = { 0x01, 0x00,
3482                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x02,
3483                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
3484                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
3485
3486 static const struct generic_data load_irks_nval_param2_test = {
3487         .send_opcode = MGMT_OP_LOAD_IRKS,
3488         .send_param = load_irks_nval_rand_addr,
3489         .send_len = sizeof(load_irks_nval_rand_addr),
3490         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3491 };
3492
3493 static const char load_irks_nval_len[] = { 0x02, 0x00, 0xff, 0xff };
3494
3495 static const struct generic_data load_irks_nval_param3_test = {
3496         .send_opcode = MGMT_OP_LOAD_IRKS,
3497         .send_param = load_irks_nval_len,
3498         .send_len = sizeof(load_irks_nval_len),
3499         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3500 };
3501
3502 static const struct generic_data load_irks_not_supported_test = {
3503         .send_opcode = MGMT_OP_LOAD_IRKS,
3504         .send_param = load_irks_empty_list,
3505         .send_len = sizeof(load_irks_empty_list),
3506         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
3507 };
3508
3509 static const char set_privacy_valid_param[] = { 0x01,
3510                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
3511                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
3512 static const char set_privacy_settings_param[] = { 0x80, 0x20, 0x00, 0x00 };
3513
3514 static const struct generic_data set_privacy_success_test = {
3515         .send_opcode = MGMT_OP_SET_PRIVACY,
3516         .send_param = set_privacy_valid_param,
3517         .send_len = sizeof(set_privacy_valid_param),
3518         .expect_status = MGMT_STATUS_SUCCESS,
3519         .expect_param = set_privacy_settings_param,
3520         .expect_len = sizeof(set_privacy_settings_param),
3521         .expect_settings_set = MGMT_SETTING_PRIVACY,
3522 };
3523
3524 static const struct generic_data set_privacy_powered_test = {
3525         .setup_settings = settings_powered,
3526         .send_opcode = MGMT_OP_SET_PRIVACY,
3527         .send_param = set_privacy_valid_param,
3528         .send_len = sizeof(set_privacy_valid_param),
3529         .expect_status = MGMT_STATUS_REJECTED,
3530 };
3531
3532 static const char set_privacy_nval_param[] = { 0xff,
3533                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
3534                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
3535 static const struct generic_data set_privacy_nval_param_test = {
3536         .send_opcode = MGMT_OP_SET_PRIVACY,
3537         .send_param = set_privacy_nval_param,
3538         .send_len = sizeof(set_privacy_nval_param),
3539         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3540 };
3541
3542 static const void *get_conn_info_send_param_func(uint16_t *len)
3543 {
3544         struct test_data *data = tester_get_data();
3545         static uint8_t param[7];
3546
3547         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3548         param[6] = 0x00; /* Address type */
3549
3550         *len = sizeof(param);
3551
3552         return param;
3553 }
3554
3555 static const void *get_conn_info_expect_param_func(uint16_t *len)
3556 {
3557         struct test_data *data = tester_get_data();
3558         static uint8_t param[10];
3559
3560         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3561         param[6] = 0x00; /* Address type */
3562         param[7] = 0xff; /* RSSI (= -1) */
3563         param[8] = 0xff; /* TX power (= -1) */
3564         param[9] = 0x04; /* max TX power */
3565
3566         *len = sizeof(param);
3567
3568         return param;
3569 }
3570
3571 static const void *get_conn_info_error_expect_param_func(uint16_t *len)
3572 {
3573         struct test_data *data = tester_get_data();
3574         static uint8_t param[10];
3575
3576         /* All unset parameters shall be 0 in case of error */
3577         memset(param, 0, sizeof(param));
3578
3579         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3580         param[6] = 0x00; /* Address type */
3581
3582         *len = sizeof(param);
3583
3584         return param;
3585 }
3586
3587 static const struct generic_data get_conn_info_succes1_test = {
3588         .setup_settings = settings_powered_connectable_bondable_ssp,
3589         .send_opcode = MGMT_OP_GET_CONN_INFO,
3590         .send_func = get_conn_info_send_param_func,
3591         .expect_status = MGMT_STATUS_SUCCESS,
3592         .expect_func = get_conn_info_expect_param_func,
3593 };
3594
3595 static const struct generic_data get_conn_info_ncon_test = {
3596         .setup_settings = settings_powered_connectable_bondable_ssp,
3597         .send_opcode = MGMT_OP_GET_CONN_INFO,
3598         .send_func = get_conn_info_send_param_func,
3599         .expect_status = MGMT_STATUS_NOT_CONNECTED,
3600         .expect_func = get_conn_info_error_expect_param_func,
3601 };
3602
3603 static const void *get_conn_info_expect_param_power_off_func(uint16_t *len)
3604 {
3605         struct test_data *data = tester_get_data();
3606         static uint8_t param[10];
3607
3608         memcpy(param, hciemu_get_client_bdaddr(data->hciemu), 6);
3609         param[6] = 0x00; /* Address type */
3610         param[7] = 127; /* RSSI */
3611         param[8] = 127; /* TX power */
3612         param[9] = 127; /* max TX power */
3613
3614         *len = sizeof(param);
3615
3616         return param;
3617 }
3618
3619 static const struct generic_data get_conn_info_power_off_test = {
3620         .setup_settings = settings_powered_connectable_bondable_ssp,
3621         .send_opcode = MGMT_OP_GET_CONN_INFO,
3622         .send_func = get_conn_info_send_param_func,
3623         .force_power_off = true,
3624         .expect_status = MGMT_STATUS_NOT_POWERED,
3625         .expect_func = get_conn_info_expect_param_power_off_func,
3626 };
3627
3628 static const uint8_t load_conn_param_nval_1[16] = { 0x12, 0x11 };
3629 static const struct generic_data load_conn_params_fail_1 = {
3630         .send_opcode = MGMT_OP_LOAD_CONN_PARAM,
3631         .send_param = load_conn_param_nval_1,
3632         .send_len = sizeof(load_conn_param_nval_1),
3633         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3634 };
3635
3636 static const uint8_t add_device_nval_1[] = {
3637                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3638                                         0x00,
3639                                         0x00,
3640 };
3641 static const uint8_t add_device_rsp[] =  {
3642                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3643                                         0x00,
3644 };
3645 static const struct generic_data add_device_fail_1 = {
3646         .send_opcode = MGMT_OP_ADD_DEVICE,
3647         .send_param = add_device_nval_1,
3648         .send_len = sizeof(add_device_nval_1),
3649         .expect_param = add_device_rsp,
3650         .expect_len = sizeof(add_device_rsp),
3651         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3652 };
3653
3654 static const uint8_t add_device_nval_2[] = {
3655                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3656                                         0x00,
3657                                         0x02,
3658 };
3659 static const struct generic_data add_device_fail_2 = {
3660         .send_opcode = MGMT_OP_ADD_DEVICE,
3661         .send_param = add_device_nval_2,
3662         .send_len = sizeof(add_device_nval_2),
3663         .expect_param = add_device_rsp,
3664         .expect_len = sizeof(add_device_rsp),
3665         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3666 };
3667
3668 static const uint8_t add_device_nval_3[] = {
3669                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3670                                         0x00,
3671                                         0xff,
3672 };
3673 static const struct generic_data add_device_fail_3 = {
3674         .send_opcode = MGMT_OP_ADD_DEVICE,
3675         .send_param = add_device_nval_3,
3676         .send_len = sizeof(add_device_nval_3),
3677         .expect_param = add_device_rsp,
3678         .expect_len = sizeof(add_device_rsp),
3679         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3680 };
3681
3682 static const uint8_t add_device_nval_4[] = {
3683                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3684                                         0x02,
3685                                         0x02,
3686 };
3687 static const uint8_t add_device_rsp_4[] =  {
3688                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3689                                         0x02,
3690 };
3691 static const struct generic_data add_device_fail_4 = {
3692         .send_opcode = MGMT_OP_ADD_DEVICE,
3693         .send_param = add_device_nval_4,
3694         .send_len = sizeof(add_device_nval_4),
3695         .expect_param = add_device_rsp_4,
3696         .expect_len = sizeof(add_device_rsp_4),
3697         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3698 };
3699
3700 static const uint8_t add_device_success_param_1[] = {
3701                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3702                                         0x00,
3703                                         0x01,
3704 };
3705 static const struct generic_data add_device_success_1 = {
3706         .send_opcode = MGMT_OP_ADD_DEVICE,
3707         .send_param = add_device_success_param_1,
3708         .send_len = sizeof(add_device_success_param_1),
3709         .expect_param = add_device_rsp,
3710         .expect_len = sizeof(add_device_rsp),
3711         .expect_status = MGMT_STATUS_SUCCESS,
3712         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
3713         .expect_alt_ev_param = add_device_success_param_1,
3714         .expect_alt_ev_len = sizeof(add_device_success_param_1),
3715 };
3716
3717 static const uint8_t add_device_success_param_2[] = {
3718                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3719                                         0x01,
3720                                         0x00,
3721 };
3722 static const uint8_t add_device_rsp_le[] =  {
3723                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3724                                         0x01,
3725 };
3726 static const struct generic_data add_device_success_2 = {
3727         .send_opcode = MGMT_OP_ADD_DEVICE,
3728         .send_param = add_device_success_param_2,
3729         .send_len = sizeof(add_device_success_param_2),
3730         .expect_param = add_device_rsp_le,
3731         .expect_len = sizeof(add_device_rsp_le),
3732         .expect_status = MGMT_STATUS_SUCCESS,
3733         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
3734         .expect_alt_ev_param = add_device_success_param_2,
3735         .expect_alt_ev_len = sizeof(add_device_success_param_2),
3736 };
3737
3738 static const uint8_t add_device_success_param_3[] = {
3739                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3740                                         0x01,
3741                                         0x02,
3742 };
3743 static const struct generic_data add_device_success_3 = {
3744         .send_opcode = MGMT_OP_ADD_DEVICE,
3745         .send_param = add_device_success_param_3,
3746         .send_len = sizeof(add_device_success_param_3),
3747         .expect_param = add_device_rsp_le,
3748         .expect_len = sizeof(add_device_rsp_le),
3749         .expect_status = MGMT_STATUS_SUCCESS,
3750         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
3751         .expect_alt_ev_param = add_device_success_param_3,
3752         .expect_alt_ev_len = sizeof(add_device_success_param_3),
3753 };
3754
3755 static const struct generic_data add_device_success_4 = {
3756         .setup_settings = settings_powered,
3757         .send_opcode = MGMT_OP_ADD_DEVICE,
3758         .send_param = add_device_success_param_1,
3759         .send_len = sizeof(add_device_success_param_1),
3760         .expect_param = add_device_rsp,
3761         .expect_len = sizeof(add_device_rsp),
3762         .expect_status = MGMT_STATUS_SUCCESS,
3763         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
3764         .expect_alt_ev_param = add_device_success_param_1,
3765         .expect_alt_ev_len = sizeof(add_device_success_param_1),
3766         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
3767         .expect_hci_param = set_connectable_scan_enable_param,
3768         .expect_hci_len = sizeof(set_connectable_scan_enable_param),
3769 };
3770
3771 static const uint8_t le_scan_enable[] = { 0x01, 0x01 };
3772 static const struct generic_data add_device_success_5 = {
3773         .setup_settings = settings_powered_le,
3774         .send_opcode = MGMT_OP_ADD_DEVICE,
3775         .send_param = add_device_success_param_2,
3776         .send_len = sizeof(add_device_success_param_2),
3777         .expect_param = add_device_rsp_le,
3778         .expect_len = sizeof(add_device_rsp_le),
3779         .expect_status = MGMT_STATUS_SUCCESS,
3780         .expect_alt_ev = MGMT_EV_DEVICE_ADDED,
3781         .expect_alt_ev_param = add_device_success_param_2,
3782         .expect_alt_ev_len = sizeof(add_device_success_param_2),
3783         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_ENABLE,
3784         .expect_hci_param = le_scan_enable,
3785         .expect_hci_len = sizeof(le_scan_enable),
3786 };
3787
3788 static const uint8_t remove_device_nval_1[] = {
3789                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3790                                         0xff,
3791 };
3792 static const struct generic_data remove_device_fail_1 = {
3793         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3794         .send_param = remove_device_nval_1,
3795         .send_len = sizeof(remove_device_nval_1),
3796         .expect_param = remove_device_nval_1,
3797         .expect_len = sizeof(remove_device_nval_1),
3798         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3799 };
3800
3801 static const uint8_t remove_device_param_1[] = {
3802                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3803                                         0x00,
3804 };
3805 static const struct generic_data remove_device_fail_2 = {
3806         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3807         .send_param = remove_device_param_1,
3808         .send_len = sizeof(remove_device_param_1),
3809         .expect_param = remove_device_param_1,
3810         .expect_len = sizeof(remove_device_param_1),
3811         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3812 };
3813
3814 static const uint8_t remove_device_param_3[] = {
3815                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3816                                         0x02,
3817 };
3818 static const struct generic_data remove_device_fail_3 = {
3819         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3820         .send_param = remove_device_param_3,
3821         .send_len = sizeof(remove_device_param_3),
3822         .expect_param = remove_device_param_3,
3823         .expect_len = sizeof(remove_device_param_3),
3824         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3825 };
3826
3827 static const struct generic_data remove_device_success_1 = {
3828         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3829         .send_param = remove_device_param_1,
3830         .send_len = sizeof(remove_device_param_1),
3831         .expect_param = remove_device_param_1,
3832         .expect_len = sizeof(remove_device_param_1),
3833         .expect_status = MGMT_STATUS_SUCCESS,
3834         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
3835         .expect_alt_ev_param = remove_device_param_1,
3836         .expect_alt_ev_len = sizeof(remove_device_param_1),
3837 };
3838
3839 static const struct generic_data remove_device_success_2 = {
3840         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3841         .send_param = remove_device_param_1,
3842         .send_len = sizeof(remove_device_param_1),
3843         .expect_param = remove_device_param_1,
3844         .expect_len = sizeof(remove_device_param_1),
3845         .expect_status = MGMT_STATUS_SUCCESS,
3846         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
3847         .expect_alt_ev_param = remove_device_param_1,
3848         .expect_alt_ev_len = sizeof(remove_device_param_1),
3849         .expect_hci_command = BT_HCI_CMD_WRITE_SCAN_ENABLE,
3850         .expect_hci_param = set_connectable_off_scan_enable_param,
3851         .expect_hci_len = sizeof(set_connectable_off_scan_enable_param),
3852 };
3853
3854 static const struct generic_data remove_device_success_3 = {
3855         .setup_settings = settings_powered,
3856         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3857         .send_param = remove_device_param_1,
3858         .send_len = sizeof(remove_device_param_1),
3859         .expect_param = remove_device_param_1,
3860         .expect_len = sizeof(remove_device_param_1),
3861         .expect_status = MGMT_STATUS_SUCCESS,
3862         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
3863         .expect_alt_ev_param = remove_device_param_1,
3864         .expect_alt_ev_len = sizeof(remove_device_param_1),
3865 };
3866
3867 static const uint8_t remove_device_param_2[] =  {
3868                                         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc,
3869                                         0x01,
3870 };
3871 static const struct generic_data remove_device_success_4 = {
3872         .setup_settings = settings_powered,
3873         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3874         .send_param = remove_device_param_2,
3875         .send_len = sizeof(remove_device_param_2),
3876         .expect_param = remove_device_param_2,
3877         .expect_len = sizeof(remove_device_param_2),
3878         .expect_status = MGMT_STATUS_SUCCESS,
3879         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
3880         .expect_alt_ev_param = remove_device_param_2,
3881         .expect_alt_ev_len = sizeof(remove_device_param_2),
3882 };
3883
3884 static const struct generic_data remove_device_success_5 = {
3885         .send_opcode = MGMT_OP_REMOVE_DEVICE,
3886         .send_param = remove_device_param_2,
3887         .send_len = sizeof(remove_device_param_2),
3888         .expect_param = remove_device_param_2,
3889         .expect_len = sizeof(remove_device_param_2),
3890         .expect_status = MGMT_STATUS_SUCCESS,
3891         .expect_alt_ev = MGMT_EV_DEVICE_REMOVED,
3892         .expect_alt_ev_param = remove_device_param_2,
3893         .expect_alt_ev_len = sizeof(remove_device_param_2),
3894 };
3895
3896 static const struct generic_data read_adv_features_invalid_param_test = {
3897         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
3898         .send_param = dummy_data,
3899         .send_len = sizeof(dummy_data),
3900         .expect_status = MGMT_STATUS_INVALID_PARAMS,
3901 };
3902
3903 static const struct generic_data read_adv_features_invalid_index_test = {
3904         .send_index_none = true,
3905         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
3906         .expect_status = MGMT_STATUS_INVALID_INDEX,
3907 };
3908
3909 static const uint8_t read_adv_features_rsp_1[] =  {
3910         0x1f, 0x00, 0x00, 0x00, /* supported flags */
3911         0x1f,                   /* max_adv_data_len */
3912         0x1f,                   /* max_scan_rsp_len */
3913         0x05,                   /* max_instances */
3914         0x00,                   /* num_instances */
3915 };
3916
3917 static const struct generic_data read_adv_features_success_1 = {
3918         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
3919         .expect_param = read_adv_features_rsp_1,
3920         .expect_len = sizeof(read_adv_features_rsp_1),
3921         .expect_status = MGMT_STATUS_SUCCESS,
3922 };
3923
3924 static const uint8_t read_adv_features_rsp_2[] =  {
3925         0x1f, 0x00, 0x00, 0x00, /* supported flags */
3926         0x1f,                   /* max_adv_data_len */
3927         0x1f,                   /* max_scan_rsp_len */
3928         0x05,                   /* max_instances */
3929         0x01,                   /* num_instances */
3930         0x01,                   /* instance identifiers */
3931 };
3932
3933 static const struct generic_data read_adv_features_success_2 = {
3934         .send_opcode = MGMT_OP_READ_ADV_FEATURES,
3935         .expect_param = read_adv_features_rsp_2,
3936         .expect_len = sizeof(read_adv_features_rsp_2),
3937         .expect_status = MGMT_STATUS_SUCCESS,
3938 };
3939
3940 /* simple add advertising command */
3941 static const uint8_t add_advertising_param_uuid[] = {
3942         0x01,                   /* adv instance */
3943         0x00, 0x00, 0x00, 0x00, /* flags: none */
3944         0x00, 0x00,             /* duration: default */
3945         0x00, 0x00,             /* timeout: none */
3946         0x09,                   /* adv data len */
3947         0x00,                   /* scan rsp len */
3948         /* adv data: */
3949         0x03,                   /* AD len */
3950         0x02,                   /* AD type: some 16 bit service class UUIDs */
3951         0x0d, 0x18,             /* heart rate monitor */
3952         0x04,                   /* AD len */
3953         0xff,                   /* AD type: manufacturer specific data */
3954         0x01, 0x02, 0x03,       /* custom advertising data */
3955 };
3956
3957 /* add advertising with scan response data */
3958 static const uint8_t add_advertising_param_scanrsp[] = {
3959         /* instance, flags, duration, timeout, adv data len: same as before */
3960         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
3961         0x0a,                   /* scan rsp len */
3962         /* adv data: same as before */
3963         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
3964         /* scan rsp data: */
3965         0x03,                   /* AD len */
3966         0x19,                   /* AD type: external appearance */
3967         0x40, 0x03,             /* some custom appearance */
3968         0x05,                   /* AD len */
3969         0x03,                   /* AD type: all 16 bit service class UUIDs */
3970         0x0d, 0x18,             /* heart rate monitor */
3971         0x0f, 0x18,             /* battery service */
3972 };
3973
3974 /* add advertising with timeout */
3975 static const uint8_t add_advertising_param_timeout[] = {
3976         /* instance, flags, duration: same as before */
3977         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3978         0x05, 0x00,             /* timeout: 5 seconds */
3979         /* adv data: same as before */
3980         0x09, 0x00, 0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
3981 };
3982
3983 /* add advertising with connectable flag */
3984 static const uint8_t add_advertising_param_connectable[] = {
3985         0x01,                   /* adv instance */
3986         0x01, 0x00, 0x00, 0x00, /* flags: connectable*/
3987         /* duration, timeout, adv/scan data: same as before */
3988         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
3989         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
3990 };
3991
3992 /* add advertising with general discoverable flag */
3993 static const uint8_t add_advertising_param_general_discov[] = {
3994         0x01,                   /* adv instance */
3995         0x02, 0x00, 0x00, 0x00, /* flags: general discoverable*/
3996         /* duration, timeout, adv/scan data: same as before */
3997         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
3998         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
3999 };
4000
4001 /* add advertising with limited discoverable flag */
4002 static const uint8_t add_advertising_param_limited_discov[] = {
4003         0x01,                   /* adv instance */
4004         0x04, 0x00, 0x00, 0x00, /* flags: limited discoverable */
4005         /* duration, timeout, adv/scan data: same as before */
4006         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4007         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4008 };
4009
4010 /* add advertising with managed flags */
4011 static const uint8_t add_advertising_param_managed[] = {
4012         0x01,                   /* adv instance */
4013         0x08, 0x00, 0x00, 0x00, /* flags: managed flags */
4014         /* duration, timeout, adv/scan data: same as before */
4015         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4016         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4017 };
4018
4019 /* add advertising with tx power flag */
4020 static const uint8_t add_advertising_param_txpwr[] = {
4021         0x01,                   /* adv instance */
4022         0x10, 0x00, 0x00, 0x00, /* flags: tx power */
4023         /* duration, timeout, adv/scan data: same as before */
4024         0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4025         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4026 };
4027
4028 /* add advertising command for a second instance */
4029 static const uint8_t add_advertising_param_test2[] = {
4030         0x02,                           /* adv instance */
4031         0x00, 0x00, 0x00, 0x00,         /* flags: none */
4032         0x00, 0x00,                     /* duration: default */
4033         0x01, 0x00,                     /* timeout: 1 second */
4034         0x07,                           /* adv data len */
4035         0x00,                           /* scan rsp len */
4036         /* adv data: */
4037         0x06,                           /* AD len */
4038         0x08,                           /* AD type: shortened local name */
4039         0x74, 0x65, 0x73, 0x74, 0x32,   /* "test2" */
4040 };
4041
4042 static const uint8_t advertising_instance1_param[] = {
4043         0x01,
4044 };
4045
4046 static const uint8_t advertising_instance2_param[] = {
4047         0x02,
4048 };
4049
4050 static const uint8_t set_adv_data_uuid[] = {
4051         /* adv data len */
4052         0x09,
4053         /* advertise heart rate monitor and manufacturer specific data */
4054         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4055         /* padding */
4056         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4057         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4058         0x00, 0x00,
4059 };
4060
4061 static const uint8_t set_adv_data_test1[] = {
4062         0x07,                           /* adv data len */
4063         0x06,                           /* AD len */
4064         0x08,                           /* AD type: shortened local name */
4065         0x74, 0x65, 0x73, 0x74, 0x31,   /* "test1" */
4066         /* padding */
4067         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4068         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4069         0x00, 0x00, 0x00, 0x00,
4070 };
4071
4072 static const uint8_t set_adv_data_test2[] = {
4073         0x07,                           /* adv data len */
4074         0x06,                           /* AD len */
4075         0x08,                           /* AD type: shortened local name */
4076         0x74, 0x65, 0x73, 0x74, 0x32,   /* "test2" */
4077         /* padding */
4078         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4079         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4080         0x00, 0x00, 0x00, 0x00,
4081 };
4082
4083 static const uint8_t set_adv_data_txpwr[] = {
4084         0x03,                   /* adv data len */
4085         0x02,                   /* AD len */
4086         0x0a,                   /* AD type: tx power */
4087         0x00,                   /* tx power */
4088         /* padding */
4089         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4090         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4091         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4092 };
4093
4094 static const uint8_t set_adv_data_general_discov[] = {
4095         0x0c,                   /* adv data len */
4096         0x02,                   /* AD len */
4097         0x01,                   /* AD type: flags */
4098         0x02,                   /* general discoverable */
4099         0x03,                   /* AD len */
4100         0x02,                   /* AD type: some 16bit service class UUIDs */
4101         0x0d, 0x18,             /* heart rate monitor */
4102         0x04,                   /* AD len */
4103         0xff,                   /* AD type: manufacturer specific data */
4104         0x01, 0x02, 0x03,       /* custom advertising data */
4105         /* padding */
4106         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4107         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4108 };
4109
4110 static const uint8_t set_adv_data_limited_discov[] = {
4111         0x0c,                   /* adv data len */
4112         0x02,                   /* AD len */
4113         0x01,                   /* AD type: flags */
4114         0x01,                   /* limited discoverable */
4115         /* rest: same as before */
4116         0x03, 0x02, 0x0d, 0x18, 0x04, 0xff, 0x01, 0x02, 0x03,
4117         /* padding */
4118         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4119         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4120 };
4121
4122 static const uint8_t set_adv_data_uuid_txpwr[] = {
4123         0x0c,                   /* adv data len */
4124         0x03,                   /* AD len */
4125         0x02,                   /* AD type: some 16bit service class UUIDs */
4126         0x0d, 0x18,             /* heart rate monitor */
4127         0x04,                   /* AD len */
4128         0xff,                   /* AD type: manufacturer specific data */
4129         0x01, 0x02, 0x03,       /* custom advertising data */
4130         0x02,                   /* AD len */
4131         0x0a,                   /* AD type: tx power */
4132         0x00,                   /* tx power */
4133         /* padding */
4134         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4135         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4136 };
4137
4138 static const uint8_t set_scan_rsp_uuid[] = {
4139         0x0a,                   /* scan rsp data len */
4140         0x03,                   /* AD len */
4141         0x19,                   /* AD type: external appearance */
4142         0x40, 0x03,             /* some custom appearance */
4143         0x05,                   /* AD len */
4144         0x03,                   /* AD type: all 16 bit service class UUIDs */
4145         0x0d, 0x18, 0x0f, 0x18, /* heart rate monitor, battery service */
4146         /* padding */
4147         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4148         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4149         0x00,
4150 };
4151
4152 static const uint8_t add_advertising_invalid_param_1[] = {
4153         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
4154         0x03, 0x03, 0x0d, 0x18,
4155         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4156         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4157         0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
4158 };
4159
4160 static const uint8_t add_advertising_invalid_param_2[] = {
4161         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4162         0x04, 0x03, 0x0d, 0x18,
4163         0x04, 0xff, 0x01, 0x02, 0x03,
4164 };
4165
4166 static const uint8_t add_advertising_invalid_param_3[] = {
4167         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4168         0x03, 0x03, 0x0d, 0x18,
4169         0x02, 0xff, 0x01, 0x02, 0x03,
4170 };
4171
4172 static const uint8_t add_advertising_invalid_param_4[] = {
4173         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00,
4174         0x03, 0x03, 0x0d, 0x18,
4175         0x05, 0xff, 0x01, 0x02, 0x03,
4176 };
4177
4178 static const uint8_t add_advertising_invalid_param_5[] = {
4179         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1D, 0x00,
4180         0x03, 0x03, 0x0d, 0x18,
4181         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4182         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4183         0x15, 0x16, 0x17, 0x18,
4184 };
4185
4186 static const uint8_t add_advertising_invalid_param_6[] = {
4187         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
4188         0x03, 0x03, 0x0d, 0x18,
4189         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4190         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4191         0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
4192 };
4193
4194 static const uint8_t add_advertising_invalid_param_7[] = {
4195         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4196         0x04, 0x03, 0x0d, 0x18,
4197         0x04, 0xff, 0x01, 0x02, 0x03,
4198 };
4199
4200 static const uint8_t add_advertising_invalid_param_8[] = {
4201         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4202         0x03, 0x03, 0x0d, 0x18,
4203         0x02, 0xff, 0x01, 0x02, 0x03,
4204 };
4205
4206 static const uint8_t add_advertising_invalid_param_9[] = {
4207         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
4208         0x03, 0x03, 0x0d, 0x18,
4209         0x05, 0xff, 0x01, 0x02, 0x03,
4210 };
4211
4212 static const uint8_t add_advertising_invalid_param_10[] = {
4213         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1D,
4214         0x03, 0x03, 0x0d, 0x18,
4215         0x19, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
4216         0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
4217         0x15, 0x16, 0x17, 0x18,
4218 };
4219
4220 static const struct generic_data add_advertising_fail_1 = {
4221         .setup_settings = settings_powered,
4222         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4223         .send_param = add_advertising_param_uuid,
4224         .send_len = sizeof(add_advertising_param_uuid),
4225         .expect_status = MGMT_STATUS_REJECTED,
4226 };
4227
4228 static const struct generic_data add_advertising_fail_2 = {
4229         .setup_settings = settings_powered_le,
4230         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4231         .send_param = add_advertising_invalid_param_1,
4232         .send_len = sizeof(add_advertising_invalid_param_1),
4233         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4234 };
4235
4236 static const struct generic_data add_advertising_fail_3 = {
4237         .setup_settings = settings_powered_le,
4238         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4239         .send_param = add_advertising_invalid_param_2,
4240         .send_len = sizeof(add_advertising_invalid_param_2),
4241         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4242 };
4243
4244 static const struct generic_data add_advertising_fail_4 = {
4245         .setup_settings = settings_powered_le,
4246         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4247         .send_param = add_advertising_invalid_param_3,
4248         .send_len = sizeof(add_advertising_invalid_param_3),
4249         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4250 };
4251
4252 static const struct generic_data add_advertising_fail_5 = {
4253         .setup_settings = settings_powered_le,
4254         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4255         .send_param = add_advertising_invalid_param_4,
4256         .send_len = sizeof(add_advertising_invalid_param_4),
4257         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4258 };
4259
4260 static const struct generic_data add_advertising_fail_6 = {
4261         .setup_settings = settings_powered_le,
4262         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4263         .send_param = add_advertising_invalid_param_5,
4264         .send_len = sizeof(add_advertising_invalid_param_5),
4265         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4266 };
4267
4268 static const struct generic_data add_advertising_fail_7 = {
4269         .setup_settings = settings_powered_le,
4270         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4271         .send_param = add_advertising_invalid_param_6,
4272         .send_len = sizeof(add_advertising_invalid_param_6),
4273         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4274 };
4275
4276 static const struct generic_data add_advertising_fail_8 = {
4277         .setup_settings = settings_powered_le,
4278         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4279         .send_param = add_advertising_invalid_param_7,
4280         .send_len = sizeof(add_advertising_invalid_param_7),
4281         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4282 };
4283
4284 static const struct generic_data add_advertising_fail_9 = {
4285         .setup_settings = settings_powered_le,
4286         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4287         .send_param = add_advertising_invalid_param_8,
4288         .send_len = sizeof(add_advertising_invalid_param_8),
4289         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4290 };
4291
4292 static const struct generic_data add_advertising_fail_10 = {
4293         .setup_settings = settings_powered_le,
4294         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4295         .send_param = add_advertising_invalid_param_9,
4296         .send_len = sizeof(add_advertising_invalid_param_9),
4297         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4298 };
4299
4300 static const struct generic_data add_advertising_fail_11 = {
4301         .setup_settings = settings_powered_le,
4302         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4303         .send_param = add_advertising_invalid_param_10,
4304         .send_len = sizeof(add_advertising_invalid_param_10),
4305         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4306 };
4307
4308 static const struct generic_data add_advertising_fail_12 = {
4309         .setup_settings = settings_le,
4310         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4311         .send_param = add_advertising_param_timeout,
4312         .send_len = sizeof(add_advertising_param_timeout),
4313         .expect_status = MGMT_STATUS_REJECTED,
4314 };
4315
4316 static const struct generic_data add_advertising_success_1 = {
4317         .setup_settings = settings_powered_le,
4318         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4319         .send_param = add_advertising_param_uuid,
4320         .send_len = sizeof(add_advertising_param_uuid),
4321         .expect_param = advertising_instance1_param,
4322         .expect_len = sizeof(advertising_instance1_param),
4323         .expect_status = MGMT_STATUS_SUCCESS,
4324         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
4325         .expect_alt_ev_param = advertising_instance1_param,
4326         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4327         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4328         .expect_hci_param = set_adv_data_uuid,
4329         .expect_hci_len = sizeof(set_adv_data_uuid),
4330 };
4331
4332 static const char set_powered_adv_instance_settings_param[] = {
4333         0x81, 0x02, 0x00, 0x00,
4334 };
4335
4336 static const struct generic_data add_advertising_success_pwron_data = {
4337         .send_opcode = MGMT_OP_SET_POWERED,
4338         .send_param = set_powered_on_param,
4339         .send_len = sizeof(set_powered_on_param),
4340         .expect_status = MGMT_STATUS_SUCCESS,
4341         .expect_param = set_powered_adv_instance_settings_param,
4342         .expect_len = sizeof(set_powered_adv_instance_settings_param),
4343         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4344         .expect_hci_param = set_adv_data_test1,
4345         .expect_hci_len = sizeof(set_adv_data_test1),
4346 };
4347
4348 static const struct generic_data add_advertising_success_pwron_enabled = {
4349         .send_opcode = MGMT_OP_SET_POWERED,
4350         .send_param = set_powered_on_param,
4351         .send_len = sizeof(set_powered_on_param),
4352         .expect_status = MGMT_STATUS_SUCCESS,
4353         .expect_param = set_powered_adv_instance_settings_param,
4354         .expect_len = sizeof(set_powered_adv_instance_settings_param),
4355         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
4356         .expect_hci_param = set_adv_on_set_adv_enable_param,
4357         .expect_hci_len = sizeof(set_adv_on_set_adv_enable_param),
4358 };
4359
4360 static const struct generic_data add_advertising_success_4 = {
4361         .send_opcode = MGMT_OP_SET_ADVERTISING,
4362         .send_param = set_adv_on_param,
4363         .send_len = sizeof(set_adv_on_param),
4364         .expect_status = MGMT_STATUS_SUCCESS,
4365         .expect_param = set_adv_settings_param_2,
4366         .expect_len = sizeof(set_adv_settings_param_2),
4367         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4368         .expect_hci_param = set_adv_data_txpwr,
4369         .expect_hci_len = sizeof(set_adv_data_txpwr),
4370 };
4371
4372 static const struct generic_data add_advertising_success_5 = {
4373         .send_opcode = MGMT_OP_SET_ADVERTISING,
4374         .send_param = set_adv_off_param,
4375         .send_len = sizeof(set_adv_off_param),
4376         .expect_status = MGMT_STATUS_SUCCESS,
4377         .expect_param = set_powered_adv_instance_settings_param,
4378         .expect_len = sizeof(set_powered_adv_instance_settings_param),
4379         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4380         .expect_hci_param = set_adv_data_test1,
4381         .expect_hci_len = sizeof(set_adv_data_test1),
4382 };
4383
4384 static const struct generic_data add_advertising_success_6 = {
4385         .setup_settings = settings_powered_le,
4386         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4387         .send_param = add_advertising_param_scanrsp,
4388         .send_len = sizeof(add_advertising_param_scanrsp),
4389         .expect_param = advertising_instance1_param,
4390         .expect_len = sizeof(advertising_instance1_param),
4391         .expect_status = MGMT_STATUS_SUCCESS,
4392         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
4393         .expect_alt_ev_param = advertising_instance1_param,
4394         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4395         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4396         .expect_hci_param = set_adv_data_uuid,
4397         .expect_hci_len = sizeof(set_adv_data_uuid),
4398 };
4399
4400 static const struct generic_data add_advertising_success_7 = {
4401         .setup_settings = settings_powered_le,
4402         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4403         .send_param = add_advertising_param_scanrsp,
4404         .send_len = sizeof(add_advertising_param_scanrsp),
4405         .expect_param = advertising_instance1_param,
4406         .expect_len = sizeof(advertising_instance1_param),
4407         .expect_status = MGMT_STATUS_SUCCESS,
4408         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
4409         .expect_alt_ev_param = advertising_instance1_param,
4410         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4411         .expect_hci_command = BT_HCI_CMD_LE_SET_SCAN_RSP_DATA,
4412         .expect_hci_param = set_scan_rsp_uuid,
4413         .expect_hci_len = sizeof(set_scan_rsp_uuid),
4414 };
4415
4416 static const struct generic_data add_advertising_success_8 = {
4417         .setup_settings = settings_powered_le,
4418         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4419         .send_param = add_advertising_param_connectable,
4420         .send_len = sizeof(add_advertising_param_connectable),
4421         .expect_param = advertising_instance1_param,
4422         .expect_len = sizeof(advertising_instance1_param),
4423         .expect_status = MGMT_STATUS_SUCCESS,
4424         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
4425         .expect_hci_param = set_connectable_on_adv_param,
4426         .expect_hci_len = sizeof(set_connectable_on_adv_param),
4427 };
4428
4429 static const struct generic_data add_advertising_success_9 = {
4430         .setup_settings = settings_powered_le,
4431         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4432         .send_param = add_advertising_param_general_discov,
4433         .send_len = sizeof(add_advertising_param_general_discov),
4434         .expect_param = advertising_instance1_param,
4435         .expect_len = sizeof(advertising_instance1_param),
4436         .expect_status = MGMT_STATUS_SUCCESS,
4437         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4438         .expect_hci_param = set_adv_data_general_discov,
4439         .expect_hci_len = sizeof(set_adv_data_general_discov),
4440 };
4441
4442 static const struct generic_data add_advertising_success_10 = {
4443         .setup_settings = settings_powered_le,
4444         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4445         .send_param = add_advertising_param_limited_discov,
4446         .send_len = sizeof(add_advertising_param_limited_discov),
4447         .expect_param = advertising_instance1_param,
4448         .expect_len = sizeof(advertising_instance1_param),
4449         .expect_status = MGMT_STATUS_SUCCESS,
4450         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4451         .expect_hci_param = set_adv_data_limited_discov,
4452         .expect_hci_len = sizeof(set_adv_data_limited_discov),
4453 };
4454
4455 static const struct generic_data add_advertising_success_11 = {
4456         .setup_settings = settings_powered_le_discoverable,
4457         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4458         .send_param = add_advertising_param_managed,
4459         .send_len = sizeof(add_advertising_param_managed),
4460         .expect_param = advertising_instance1_param,
4461         .expect_len = sizeof(advertising_instance1_param),
4462         .expect_status = MGMT_STATUS_SUCCESS,
4463         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4464         .expect_hci_param = set_adv_data_general_discov,
4465         .expect_hci_len = sizeof(set_adv_data_general_discov),
4466 };
4467
4468 static const struct generic_data add_advertising_success_12 = {
4469         .setup_settings = settings_powered_le_discoverable,
4470         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4471         .send_param = add_advertising_param_txpwr,
4472         .send_len = sizeof(add_advertising_param_txpwr),
4473         .expect_param = advertising_instance1_param,
4474         .expect_len = sizeof(advertising_instance1_param),
4475         .expect_status = MGMT_STATUS_SUCCESS,
4476         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4477         .expect_hci_param = set_adv_data_uuid_txpwr,
4478         .expect_hci_len = sizeof(set_adv_data_uuid_txpwr),
4479 };
4480
4481 static uint16_t settings_powered_le_connectable[] = {
4482                                                 MGMT_OP_SET_POWERED,
4483                                                 MGMT_OP_SET_LE,
4484                                                 MGMT_OP_SET_CONNECTABLE, 0 };
4485
4486 static uint8_t set_connectable_off_scan_adv_param[] = {
4487                 0x00, 0x08,                             /* min_interval */
4488                 0x00, 0x08,                             /* max_interval */
4489                 0x02,                                   /* type */
4490                 0x01,                                   /* own_addr_type */
4491                 0x00,                                   /* direct_addr_type */
4492                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     /* direct_addr */
4493                 0x07,                                   /* channel_map */
4494                 0x00,                                   /* filter_policy */
4495 };
4496
4497 static const struct generic_data add_advertising_success_13 = {
4498         .setup_settings = settings_powered_le,
4499         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4500         .send_param = add_advertising_param_scanrsp,
4501         .send_len = sizeof(add_advertising_param_scanrsp),
4502         .expect_param = advertising_instance1_param,
4503         .expect_len = sizeof(advertising_instance1_param),
4504         .expect_status = MGMT_STATUS_SUCCESS,
4505         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
4506         .expect_hci_param = set_connectable_off_scan_adv_param,
4507         .expect_hci_len = sizeof(set_connectable_off_scan_adv_param),
4508 };
4509
4510 static const struct generic_data add_advertising_success_14 = {
4511         .setup_settings = settings_powered_le,
4512         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4513         .send_param = add_advertising_param_uuid,
4514         .send_len = sizeof(add_advertising_param_uuid),
4515         .expect_param = advertising_instance1_param,
4516         .expect_len = sizeof(advertising_instance1_param),
4517         .expect_status = MGMT_STATUS_SUCCESS,
4518         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
4519         .expect_hci_param = set_connectable_off_adv_param,
4520         .expect_hci_len = sizeof(set_connectable_off_adv_param),
4521 };
4522
4523 static const struct generic_data add_advertising_success_15 = {
4524         .setup_settings = settings_powered_le_connectable,
4525         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4526         .send_param = add_advertising_param_uuid,
4527         .send_len = sizeof(add_advertising_param_uuid),
4528         .expect_param = advertising_instance1_param,
4529         .expect_len = sizeof(advertising_instance1_param),
4530         .expect_status = MGMT_STATUS_SUCCESS,
4531         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
4532         .expect_hci_param = set_connectable_on_adv_param,
4533         .expect_hci_len = sizeof(set_connectable_on_adv_param),
4534 };
4535
4536 static const char set_connectable_settings_param_3[] = {
4537                                                 0x83, 0x02, 0x00, 0x00 };
4538
4539 static const struct generic_data add_advertising_success_16 = {
4540         .send_opcode = MGMT_OP_SET_CONNECTABLE,
4541         .send_param = set_connectable_on_param,
4542         .send_len = sizeof(set_connectable_on_param),
4543         .expect_status = MGMT_STATUS_SUCCESS,
4544         .expect_param = set_connectable_settings_param_3,
4545         .expect_len = sizeof(set_connectable_settings_param_3),
4546         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
4547         .expect_hci_param = set_connectable_on_adv_param,
4548         .expect_hci_len = sizeof(set_connectable_on_adv_param),
4549 };
4550
4551 static const struct generic_data add_advertising_success_17 = {
4552         .send_opcode = MGMT_OP_SET_CONNECTABLE,
4553         .send_param = set_connectable_off_param,
4554         .send_len = sizeof(set_connectable_off_param),
4555         .expect_status = MGMT_STATUS_SUCCESS,
4556         .expect_param = set_le_settings_param_2,
4557         .expect_len = sizeof(set_le_settings_param_2),
4558         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_PARAMETERS,
4559         .expect_hci_param = set_connectable_off_adv_param,
4560         .expect_hci_len = sizeof(set_connectable_off_adv_param),
4561 };
4562
4563 static const char set_powered_off_le_settings_param[] = {
4564         0x80, 0x02, 0x00, 0x00
4565 };
4566
4567 static const struct generic_data add_advertising_power_off = {
4568         .send_opcode = MGMT_OP_SET_POWERED,
4569         .send_param = set_powered_off_param,
4570         .send_len = sizeof(set_powered_off_param),
4571         .expect_status = MGMT_STATUS_SUCCESS,
4572         .expect_param = set_powered_off_le_settings_param,
4573         .expect_len = sizeof(set_powered_off_le_settings_param),
4574         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
4575         .expect_alt_ev_param = advertising_instance1_param,
4576         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4577 };
4578
4579 static const char set_le_settings_param_off[] = { 0x81, 0x00, 0x00, 0x00 };
4580
4581 static const struct generic_data add_advertising_le_off = {
4582         .send_opcode = MGMT_OP_SET_LE,
4583         .send_param = set_le_off_param,
4584         .send_len = sizeof(set_le_off_param),
4585         .expect_status = MGMT_STATUS_SUCCESS,
4586         .expect_param = set_le_settings_param_off,
4587         .expect_len = sizeof(set_le_settings_param_off),
4588         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
4589         .expect_alt_ev_param = advertising_instance1_param,
4590         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4591 };
4592
4593 static const struct generic_data add_advertising_success_18 = {
4594         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4595         .send_param = add_advertising_param_uuid,
4596         .send_len = sizeof(add_advertising_param_uuid),
4597         .expect_param = advertising_instance1_param,
4598         .expect_len = sizeof(advertising_instance1_param),
4599         .expect_status = MGMT_STATUS_SUCCESS,
4600         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4601         .expect_hci_param = set_adv_data_uuid,
4602         .expect_hci_len = sizeof(set_adv_data_uuid),
4603 };
4604
4605 static const struct generic_data add_advertising_timeout_expired = {
4606         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
4607         .expect_alt_ev_param = advertising_instance1_param,
4608         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4609         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
4610         .expect_hci_param = set_adv_on_set_adv_disable_param,
4611         .expect_hci_len = sizeof(set_adv_on_set_adv_disable_param),
4612 };
4613
4614 static const uint8_t remove_advertising_param_1[] = {
4615         0x01,
4616 };
4617
4618 static const uint8_t remove_advertising_param_2[] = {
4619         0x00,
4620 };
4621
4622 static const struct generic_data remove_advertising_fail_1 = {
4623         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
4624         .send_param = remove_advertising_param_1,
4625         .send_len = sizeof(remove_advertising_param_1),
4626         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4627 };
4628
4629 static const struct generic_data remove_advertising_success_1 = {
4630         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
4631         .send_param = remove_advertising_param_1,
4632         .send_len = sizeof(remove_advertising_param_1),
4633         .expect_status = MGMT_STATUS_SUCCESS,
4634         .expect_param = remove_advertising_param_1,
4635         .expect_len = sizeof(remove_advertising_param_1),
4636         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
4637         .expect_alt_ev_param = advertising_instance1_param,
4638         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4639         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
4640         .expect_hci_param = set_adv_off_param,
4641         .expect_hci_len = sizeof(set_adv_off_param),
4642 };
4643
4644 static const struct generic_data remove_advertising_success_2 = {
4645         .send_opcode = MGMT_OP_REMOVE_ADVERTISING,
4646         .send_param = remove_advertising_param_2,
4647         .send_len = sizeof(remove_advertising_param_2),
4648         .expect_status = MGMT_STATUS_SUCCESS,
4649         .expect_param = remove_advertising_param_2,
4650         .expect_len = sizeof(remove_advertising_param_2),
4651         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
4652         .expect_alt_ev_param = advertising_instance1_param,
4653         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4654         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_ENABLE,
4655         .expect_hci_param = set_adv_off_param,
4656         .expect_hci_len = sizeof(set_adv_off_param),
4657 };
4658
4659 static const struct generic_data multi_advertising_switch = {
4660         .expect_alt_ev = MGMT_EV_ADVERTISING_REMOVED,
4661         .expect_alt_ev_param = advertising_instance1_param,
4662         .expect_alt_ev_len = sizeof(advertising_instance1_param),
4663         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4664         .expect_hci_param = set_adv_data_test2,
4665         .expect_hci_len = sizeof(set_adv_data_test2),
4666 };
4667
4668 static const struct generic_data multi_advertising_add_second = {
4669         .send_opcode = MGMT_OP_ADD_ADVERTISING,
4670         .send_param = add_advertising_param_test2,
4671         .send_len = sizeof(add_advertising_param_test2),
4672         .expect_param = advertising_instance2_param,
4673         .expect_len = sizeof(advertising_instance2_param),
4674         .expect_status = MGMT_STATUS_SUCCESS,
4675         .expect_alt_ev = MGMT_EV_ADVERTISING_ADDED,
4676         .expect_alt_ev_param = advertising_instance2_param,
4677         .expect_alt_ev_len = sizeof(advertising_instance2_param),
4678         .expect_hci_command = BT_HCI_CMD_LE_SET_ADV_DATA,
4679         .expect_hci_param = set_adv_data_test2,
4680         .expect_hci_len = sizeof(set_adv_data_test2),
4681 };
4682
4683 /* based on G-Tag ADV_DATA */
4684 static const uint8_t adv_data_invalid_significant_len[] = { 0x02, 0x01, 0x06,
4685                 0x0d, 0xff, 0x80, 0x01, 0x02, 0x15, 0x12, 0x34, 0x80, 0x91,
4686                 0xd0, 0xf2, 0xbb, 0xc5, 0x03, 0x02, 0x0f, 0x18, 0x00, 0x00,
4687                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
4688
4689 static const char device_found_valid[] = { 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,
4690                 0x01, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x02, 0x01,
4691                 0x06, 0x0d, 0xff, 0x80, 0x01, 0x02, 0x15, 0x12, 0x34, 0x80,
4692                 0x91, 0xd0, 0xf2, 0xbb, 0xc5, 0x03, 0x02, 0x0f, 0x18 };
4693
4694 static const struct generic_data device_found_gtag = {
4695         .setup_settings = settings_powered_le,
4696         .send_opcode = MGMT_OP_START_DISCOVERY,
4697         .send_param = start_discovery_le_param,
4698         .send_len = sizeof(start_discovery_le_param),
4699         .expect_status = MGMT_STATUS_SUCCESS,
4700         .expect_param = start_discovery_le_param,
4701         .expect_len = sizeof(start_discovery_le_param),
4702         .expect_alt_ev = MGMT_EV_DEVICE_FOUND,
4703         .expect_alt_ev_param = device_found_valid,
4704         .expect_alt_ev_len = sizeof(device_found_valid),
4705         .set_adv = true,
4706         .adv_data_len = sizeof(adv_data_invalid_significant_len),
4707         .adv_data = adv_data_invalid_significant_len,
4708 };
4709
4710 static const uint8_t adv_data_invalid_field_len[] = { 0x02, 0x01, 0x01,
4711                 0x05, 0x09, 0x74, 0x65, 0x73, 0x74,
4712                 0xa0, 0xff, 0x01, 0x02, 0x03, 0x04, 0x05};
4713
4714 static const char device_found_valid2[] = { 0x00, 0x00, 0x01, 0x01, 0xaa, 0x00,
4715                 0x01, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x02, 0x01,
4716                 0x01, 0x05, 0x09, 0x74, 0x65, 0x73, 0x74};
4717
4718 static const struct generic_data device_found_invalid_field = {
4719         .setup_settings = settings_powered_le,
4720         .send_opcode = MGMT_OP_START_DISCOVERY,
4721         .send_param = start_discovery_le_param,
4722         .send_len = sizeof(start_discovery_le_param),
4723         .expect_status = MGMT_STATUS_SUCCESS,
4724         .expect_param = start_discovery_le_param,
4725         .expect_len = sizeof(start_discovery_le_param),
4726         .expect_alt_ev = MGMT_EV_DEVICE_FOUND,
4727         .expect_alt_ev_param = device_found_valid2,
4728         .expect_alt_ev_len = sizeof(device_found_valid2),
4729         .set_adv = true,
4730         .adv_data_len = sizeof(adv_data_invalid_field_len),
4731         .adv_data = adv_data_invalid_field_len,
4732 };
4733
4734 static const struct generic_data read_local_oob_not_powered_test = {
4735         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
4736         .expect_status = MGMT_STATUS_NOT_POWERED,
4737 };
4738
4739 static const struct generic_data read_local_oob_invalid_param_test = {
4740         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
4741         .send_param = dummy_data,
4742         .send_len = sizeof(dummy_data),
4743         .expect_status = MGMT_STATUS_INVALID_PARAMS,
4744 };
4745
4746 static const struct generic_data read_local_oob_invalid_index_test = {
4747         .send_index_none = true,
4748         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
4749         .expect_status = MGMT_STATUS_INVALID_INDEX,
4750 };
4751
4752 static const struct generic_data read_local_oob_legacy_pairing_test = {
4753         .setup_settings = settings_powered,
4754         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
4755         .expect_status = MGMT_STATUS_NOT_SUPPORTED,
4756 };
4757
4758 static const struct generic_data read_local_oob_success_ssp_test = {
4759         .setup_settings = settings_powered_ssp,
4760         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
4761         .expect_status = MGMT_STATUS_SUCCESS,
4762         .expect_ignore_param = true,
4763         .expect_hci_command = BT_HCI_CMD_READ_LOCAL_OOB_DATA,
4764 };
4765
4766 static const struct generic_data read_local_oob_success_sc_test = {
4767         .setup_settings = settings_powered_sc,
4768         .send_opcode = MGMT_OP_READ_LOCAL_OOB_DATA,
4769         .expect_status = MGMT_STATUS_SUCCESS,
4770         .expect_ignore_param = true,
4771         .expect_hci_command = BT_HCI_CMD_READ_LOCAL_OOB_EXT_DATA,
4772 };
4773
4774 static void client_cmd_complete(uint16_t opcode, uint8_t status,
4775                                         const void *param, uint8_t len,
4776                                         void *user_data)
4777 {
4778         struct test_data *data = tester_get_data();
4779         const struct generic_data *test = data->test_data;
4780         struct bthost *bthost;
4781
4782         bthost = hciemu_client_get_host(data->hciemu);
4783
4784         switch (opcode) {
4785         case BT_HCI_CMD_WRITE_SCAN_ENABLE:
4786         case BT_HCI_CMD_LE_SET_ADV_ENABLE:
4787                 tester_print("Client set connectable: %s (0x%02x)",
4788                                                 mgmt_errstr(status), status);
4789                 if (!status && test->client_enable_ssp) {
4790                         bthost_write_ssp_mode(bthost, 0x01);
4791                         return;
4792                 }
4793                 break;
4794         case BT_HCI_CMD_WRITE_SIMPLE_PAIRING_MODE:
4795                 tester_print("Client enable SSP: %s (0x%02x)",
4796                                                 mgmt_errstr(status), status);
4797                 break;
4798         default:
4799                 return;
4800         }
4801
4802         if (status)
4803                 tester_setup_failed();
4804         else
4805                 tester_setup_complete();
4806 }
4807
4808 static void setup_bthost(void)
4809 {
4810         struct test_data *data = tester_get_data();
4811         struct bthost *bthost;
4812
4813         bthost = hciemu_client_get_host(data->hciemu);
4814         bthost_set_cmd_complete_cb(bthost, client_cmd_complete, data);
4815         if (data->hciemu_type == HCIEMU_TYPE_LE)
4816                 bthost_set_adv_enable(bthost, 0x01);
4817         else
4818                 bthost_write_scan_enable(bthost, 0x03);
4819 }
4820
4821 static void setup_pairing_acceptor(const void *test_data)
4822 {
4823         struct test_data *data = tester_get_data();
4824         const struct generic_data *test = data->test_data;
4825
4826         if (!test->io_cap)
4827                 return;
4828
4829         mgmt_send(data->mgmt, MGMT_OP_SET_IO_CAPABILITY, data->mgmt_index,
4830                                         sizeof(test->io_cap), &test->io_cap,
4831                                         NULL, NULL, NULL);
4832
4833         setup_bthost();
4834 }
4835
4836 static void setup_powered_callback(uint8_t status, uint16_t length,
4837                                         const void *param, void *user_data)
4838 {
4839         if (status != MGMT_STATUS_SUCCESS) {
4840                 tester_setup_failed();
4841                 return;
4842         }
4843
4844         tester_print("Controller powered on");
4845
4846         setup_bthost();
4847 }
4848
4849 static void setup_class(const void *test_data)
4850 {
4851         struct test_data *data = tester_get_data();
4852         unsigned char param[] = { 0x01 };
4853         unsigned char class_param[] = { 0x01, 0x0c };
4854
4855         tester_print("Setting device class and powering on");
4856
4857         mgmt_send(data->mgmt, MGMT_OP_SET_DEV_CLASS, data->mgmt_index,
4858                                 sizeof(class_param), class_param,
4859                                 NULL, NULL, NULL);
4860
4861         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
4862                                         sizeof(param), param,
4863                                         setup_powered_callback, NULL, NULL);
4864 }
4865
4866 static void discovering_event(uint16_t index, uint16_t length,
4867                                         const void *param, void *user_data)
4868 {
4869         struct test_data *data = tester_get_data();
4870         const struct mgmt_ev_discovering *ev = param;
4871
4872         mgmt_unregister(data->mgmt, data->mgmt_discov_ev_id);
4873
4874         if (length != sizeof(*ev)) {
4875                 tester_warn("Incorrect discovering event length");
4876                 tester_setup_failed();
4877                 return;
4878         }
4879
4880         if (!ev->discovering) {
4881                 tester_warn("Unexpected discovery stopped event");
4882                 tester_setup_failed();
4883                 return;
4884         }
4885
4886         tester_setup_complete();
4887 }
4888
4889 static void setup_discovery_callback(uint8_t status, uint16_t length,
4890                                         const void *param, void *user_data)
4891 {
4892         if (status != MGMT_STATUS_SUCCESS) {
4893                 tester_setup_failed();
4894                 return;
4895         }
4896
4897         tester_print("Discovery started");
4898 }
4899
4900 static void setup_start_discovery(const void *test_data)
4901 {
4902         struct test_data *data = tester_get_data();
4903         const struct generic_data *test = data->test_data;
4904         const void *send_param = test->setup_send_param;
4905         uint16_t send_len = test->setup_send_len;
4906         unsigned int id;
4907
4908         id = mgmt_register(data->mgmt, MGMT_EV_DISCOVERING, data->mgmt_index,
4909                            discovering_event, NULL, NULL);
4910         data->mgmt_discov_ev_id = id;
4911
4912         mgmt_send(data->mgmt, test->setup_send_opcode, data->mgmt_index,
4913                                 send_len, send_param, setup_discovery_callback,
4914                                 NULL, NULL);
4915 }
4916
4917 static void setup_multi_uuid32(const void *test_data)
4918 {
4919         struct test_data *data = tester_get_data();
4920         unsigned char param[] = { 0x01 };
4921
4922         tester_print("Powering on controller (with 32-bit UUID)");
4923
4924         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
4925                                 sizeof(param), param, NULL, NULL, NULL);
4926
4927         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
4928                                 sizeof(add_uuid32_param_1), add_uuid32_param_1,
4929                                 NULL, NULL, NULL);
4930         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
4931                                 sizeof(add_uuid32_param_2), add_uuid32_param_2,
4932                                 NULL, NULL, NULL);
4933         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
4934                                 sizeof(add_uuid32_param_3), add_uuid32_param_3,
4935                                 NULL, NULL, NULL);
4936
4937         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
4938                                         sizeof(param), param,
4939                                         setup_powered_callback, NULL, NULL);
4940 }
4941
4942 static void setup_multi_uuid32_2(const void *test_data)
4943 {
4944         struct test_data *data = tester_get_data();
4945         unsigned char param[] = { 0x01 };
4946         unsigned char uuid_param[] = {
4947                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
4948                         0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4949                         0x00 };
4950         int i;
4951
4952         tester_print("Powering on controller (with many 32-bit UUIDs)");
4953
4954         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
4955                                 sizeof(param), param, NULL, NULL, NULL);
4956
4957         for (i = 0; i < 58; i++) {
4958                 uint32_t val = htobl(0xffffffff - i);
4959                 memcpy(&uuid_param[12], &val, sizeof(val));
4960                 mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
4961                                 sizeof(uuid_param), uuid_param,
4962                                 NULL, NULL, NULL);
4963         }
4964
4965         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
4966                                         sizeof(param), param,
4967                                         setup_powered_callback, NULL, NULL);
4968 }
4969
4970 static void setup_multi_uuid128(const void *test_data)
4971 {
4972         struct test_data *data = tester_get_data();
4973         unsigned char param[] = { 0x01 };
4974
4975         tester_print("Powering on controller (with 128-bit UUID)");
4976
4977         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
4978                                 sizeof(param), param, NULL, NULL, NULL);
4979
4980         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
4981                         sizeof(add_uuid128_param_1), add_uuid128_param_1,
4982                         NULL, NULL, NULL);
4983
4984         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
4985                                         sizeof(param), param,
4986                                         setup_powered_callback, NULL, NULL);
4987 }
4988
4989 static void setup_multi_uuid128_2(const void *test_data)
4990 {
4991         struct test_data *data = tester_get_data();
4992         unsigned char param[] = { 0x01 };
4993         unsigned char uuid_param[] = {
4994                         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
4995                         0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00,
4996                         0x00 };
4997         int i;
4998
4999         tester_print("Powering on controller (with many 128-bit UUIDs)");
5000
5001         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
5002                                 sizeof(param), param, NULL, NULL, NULL);
5003
5004         for (i = 0; i < 13; i++) {
5005                 uuid_param[15] = i;
5006                 mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5007                                 sizeof(uuid_param), uuid_param,
5008                                 NULL, NULL, NULL);
5009         }
5010
5011         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5012                                         sizeof(param), param,
5013                                         setup_powered_callback, NULL, NULL);
5014 }
5015
5016 static void setup_multi_uuid16(const void *test_data)
5017 {
5018         struct test_data *data = tester_get_data();
5019         unsigned char param[] = { 0x01 };
5020
5021         tester_print("Powering on controller (with SPP UUID)");
5022
5023         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
5024                                 sizeof(param), param, NULL, NULL, NULL);
5025
5026         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5027                                 sizeof(add_spp_uuid_param), add_spp_uuid_param,
5028                                 NULL, NULL, NULL);
5029         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5030                                 sizeof(add_dun_uuid_param), add_dun_uuid_param,
5031                                 NULL, NULL, NULL);
5032         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5033                         sizeof(add_sync_uuid_param), add_sync_uuid_param,
5034                         NULL, NULL, NULL);
5035
5036         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5037                                         sizeof(param), param,
5038                                         setup_powered_callback, NULL, NULL);
5039 }
5040
5041 static void setup_multi_uuid16_2(const void *test_data)
5042 {
5043         struct test_data *data = tester_get_data();
5044         unsigned char param[] = { 0x01 };
5045         unsigned char uuid_param[] = {
5046                         0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
5047                         0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5048                         0x00 };
5049         int i;
5050
5051         tester_print("Powering on controller (with many 16-bit UUIDs)");
5052
5053         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
5054                                 sizeof(param), param, NULL, NULL, NULL);
5055
5056         for (i = 0; i < 117; i++) {
5057                 uint16_t val = htobs(i + 0x2000);
5058                 memcpy(&uuid_param[12], &val, sizeof(val));
5059                 mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5060                                 sizeof(uuid_param), uuid_param,
5061                                 NULL, NULL, NULL);
5062         }
5063
5064         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5065                                         sizeof(param), param,
5066                                         setup_powered_callback, NULL, NULL);
5067 }
5068
5069 static void setup_uuid_mix(const void *test_data)
5070 {
5071         struct test_data *data = tester_get_data();
5072         unsigned char param[] = { 0x01 };
5073
5074         tester_print("Powering on controller (with mixed UUIDs)");
5075
5076         mgmt_send(data->mgmt, MGMT_OP_SET_SSP, data->mgmt_index,
5077                                 sizeof(param), param, NULL, NULL, NULL);
5078
5079         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5080                                 sizeof(add_spp_uuid_param), add_spp_uuid_param,
5081                                 NULL, NULL, NULL);
5082         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5083                                 sizeof(add_uuid32_param_1), add_uuid32_param_1,
5084                                 NULL, NULL, NULL);
5085         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5086                         sizeof(add_uuid128_param_1), add_uuid128_param_1,
5087                         NULL, NULL, NULL);
5088
5089         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5090                                 sizeof(add_dun_uuid_param), add_dun_uuid_param,
5091                                 NULL, NULL, NULL);
5092         mgmt_send(data->mgmt, MGMT_OP_ADD_UUID, data->mgmt_index,
5093                                 sizeof(add_uuid32_param_2), add_uuid32_param_2,
5094                                 NULL, NULL, NULL);
5095
5096         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5097                                         sizeof(param), param,
5098                                         setup_powered_callback, NULL, NULL);
5099 }
5100
5101 static void setup_add_device(const void *test_data)
5102 {
5103         struct test_data *data = tester_get_data();
5104         unsigned char param[] = { 0x01 };
5105         const unsigned char *add_param;
5106         size_t add_param_len;
5107
5108         tester_print("Powering on controller (with added device)");
5109
5110         if (data->hciemu_type == HCIEMU_TYPE_LE) {
5111                 add_param = add_device_success_param_2;
5112                 add_param_len = sizeof(add_device_success_param_2);
5113         } else {
5114                 add_param = add_device_success_param_1;
5115                 add_param_len = sizeof(add_device_success_param_1);
5116         }
5117
5118         mgmt_send(data->mgmt, MGMT_OP_ADD_DEVICE, data->mgmt_index,
5119                         add_param_len, add_param, NULL, NULL, NULL);
5120
5121         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5122                                         sizeof(param), param,
5123                                         setup_powered_callback, NULL, NULL);
5124 }
5125
5126 static void setup_add_advertising_callback(uint8_t status, uint16_t length,
5127                                         const void *param, void *user_data)
5128 {
5129         struct mgmt_rp_add_advertising *rp =
5130                                 (struct mgmt_rp_add_advertising *) param;
5131
5132         if (status != MGMT_STATUS_SUCCESS) {
5133                 tester_setup_failed();
5134                 return;
5135         }
5136
5137         tester_print("Add Advertising setup complete (instance %d)",
5138                                                                 rp->instance);
5139
5140         setup_bthost();
5141 }
5142
5143 #define TESTER_ADD_ADV_DATA_LEN 7
5144
5145 static void setup_add_adv_param(struct mgmt_cp_add_advertising *cp,
5146                                                         uint8_t instance)
5147 {
5148         memset(cp, 0, sizeof(*cp));
5149         cp->instance = instance;
5150         cp->adv_data_len = TESTER_ADD_ADV_DATA_LEN;
5151         cp->data[0] = TESTER_ADD_ADV_DATA_LEN - 1; /* AD len */
5152         cp->data[1] = 0x08; /* AD type: shortened local name */
5153         cp->data[2] = 't';  /* adv data ... */
5154         cp->data[3] = 'e';
5155         cp->data[4] = 's';
5156         cp->data[5] = 't';
5157         cp->data[6] = '0' + instance;
5158 }
5159
5160 static void setup_add_advertising_not_powered(const void *test_data)
5161 {
5162         struct test_data *data = tester_get_data();
5163         struct mgmt_cp_add_advertising *cp;
5164         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5165         unsigned char param[] = { 0x01 };
5166
5167         tester_print("Adding advertising instance while unpowered");
5168
5169         cp = (struct mgmt_cp_add_advertising *) adv_param;
5170         setup_add_adv_param(cp, 1);
5171
5172         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5173                                                 sizeof(param), &param,
5174                                                 NULL, NULL, NULL);
5175
5176         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5177                                                 sizeof(adv_param), adv_param,
5178                                                 setup_add_advertising_callback,
5179                                                 NULL, NULL);
5180 }
5181
5182 static void setup_add_advertising(const void *test_data)
5183 {
5184         struct test_data *data = tester_get_data();
5185         struct mgmt_cp_add_advertising *cp;
5186         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5187         unsigned char param[] = { 0x01 };
5188
5189         tester_print("Adding advertising instance while powered");
5190
5191         cp = (struct mgmt_cp_add_advertising *) adv_param;
5192         setup_add_adv_param(cp, 1);
5193
5194         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5195                                                 sizeof(param), &param,
5196                                                 NULL, NULL, NULL);
5197
5198         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5199                                                 sizeof(param), &param,
5200                                                 NULL, NULL, NULL);
5201
5202         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5203                                                 sizeof(adv_param), adv_param,
5204                                                 setup_add_advertising_callback,
5205                                                 NULL, NULL);
5206 }
5207
5208 static void setup_add_advertising_connectable(const void *test_data)
5209 {
5210         struct test_data *data = tester_get_data();
5211         struct mgmt_cp_add_advertising *cp;
5212         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5213         unsigned char param[] = { 0x01 };
5214
5215         tester_print("Adding advertising instance while connectable");
5216
5217         cp = (struct mgmt_cp_add_advertising *) adv_param;
5218         setup_add_adv_param(cp, 1);
5219
5220         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5221                                                 sizeof(param), &param,
5222                                                 NULL, NULL, NULL);
5223
5224         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5225                                                 sizeof(param), &param,
5226                                                 NULL, NULL, NULL);
5227
5228         mgmt_send(data->mgmt, MGMT_OP_SET_CONNECTABLE, data->mgmt_index,
5229                                                 sizeof(param), &param,
5230                                                 NULL, NULL, NULL);
5231
5232         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5233                                                 sizeof(adv_param), adv_param,
5234                                                 setup_add_advertising_callback,
5235                                                 NULL, NULL);
5236 }
5237
5238 static void setup_add_advertising_timeout(const void *test_data)
5239 {
5240         struct test_data *data = tester_get_data();
5241         struct mgmt_cp_add_advertising *cp;
5242         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5243         unsigned char param[] = { 0x01 };
5244
5245         tester_print("Adding advertising instance with timeout");
5246
5247         cp = (struct mgmt_cp_add_advertising *) adv_param;
5248         setup_add_adv_param(cp, 1);
5249         cp->timeout = 1;
5250
5251         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5252                                                 sizeof(param), &param,
5253                                                 NULL, NULL, NULL);
5254
5255         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5256                                                 sizeof(param), &param,
5257                                                 NULL, NULL, NULL);
5258
5259         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5260                                                 sizeof(adv_param), adv_param,
5261                                                 setup_add_advertising_callback,
5262                                                 NULL, NULL);
5263 }
5264
5265 static void setup_add_advertising_duration(const void *test_data)
5266 {
5267         struct test_data *data = tester_get_data();
5268         struct mgmt_cp_add_advertising *cp;
5269         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5270         unsigned char param[] = { 0x01 };
5271
5272         tester_print("Adding instance with long timeout/short duration");
5273
5274         cp = (struct mgmt_cp_add_advertising *) adv_param;
5275         setup_add_adv_param(cp, 1);
5276         cp->duration = 1;
5277         cp->timeout = 30;
5278
5279         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5280                                                 sizeof(param), &param,
5281                                                 NULL, NULL, NULL);
5282
5283         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5284                                                 sizeof(param), &param,
5285                                                 NULL, NULL, NULL);
5286
5287         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5288                                                 sizeof(adv_param), adv_param,
5289                                                 setup_add_advertising_callback,
5290                                                 NULL, NULL);
5291 }
5292
5293 static void setup_power_cycle_callback(uint8_t status, uint16_t length,
5294                                         const void *param, void *user_data)
5295 {
5296         struct test_data *data = tester_get_data();
5297         unsigned char param_off[] = { 0x00 };
5298
5299         if (status != MGMT_STATUS_SUCCESS) {
5300                 tester_setup_failed();
5301                 return;
5302         }
5303
5304         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5305                                                 sizeof(param_off), &param_off,
5306                                                 NULL, NULL, NULL);
5307
5308         setup_bthost();
5309 }
5310
5311 static void setup_add_advertising_power_cycle(const void *test_data)
5312 {
5313         struct test_data *data = tester_get_data();
5314         struct mgmt_cp_add_advertising *cp;
5315         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5316         unsigned char param_on[] = { 0x01 };
5317
5318         tester_print("Adding instance without timeout and power cycle");
5319
5320         cp = (struct mgmt_cp_add_advertising *) adv_param;
5321         setup_add_adv_param(cp, 1);
5322
5323         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5324                                                 sizeof(param_on), &param_on,
5325                                                 NULL, NULL, NULL);
5326
5327         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5328                                                 sizeof(param_on), &param_on,
5329                                                 NULL, NULL, NULL);
5330
5331         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5332                                                 sizeof(adv_param), adv_param,
5333                                                 setup_power_cycle_callback,
5334                                                 NULL, NULL);
5335 }
5336
5337 static void setup_set_and_add_advertising(const void *test_data)
5338 {
5339         struct test_data *data = tester_get_data();
5340         struct mgmt_cp_add_advertising *cp;
5341         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5342         unsigned char param[] = { 0x01 };
5343
5344         tester_print("Set and add advertising instance");
5345
5346         cp = (struct mgmt_cp_add_advertising *) adv_param;
5347         setup_add_adv_param(cp, 1);
5348
5349         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5350                                                 sizeof(param), &param,
5351                                                 NULL, NULL, NULL);
5352
5353         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5354                                                 sizeof(param), &param,
5355                                                 NULL, NULL, NULL);
5356
5357         mgmt_send(data->mgmt, MGMT_OP_SET_ADVERTISING, data->mgmt_index,
5358                                                 sizeof(param), &param,
5359                                                 NULL, NULL, NULL);
5360
5361         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5362                                                 sizeof(adv_param), adv_param,
5363                                                 setup_add_advertising_callback,
5364                                                 NULL, NULL);
5365 }
5366
5367 static void setup_multi_adv_second_instance(uint8_t status, uint16_t length,
5368                 const void *param, void *user_data) {
5369         struct mgmt_rp_add_advertising *rp =
5370                                 (struct mgmt_rp_add_advertising *) param;
5371         struct test_data *data = tester_get_data();
5372         struct mgmt_cp_add_advertising *cp;
5373         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5374
5375         if (status != MGMT_STATUS_SUCCESS) {
5376                 tester_setup_failed();
5377                 return;
5378         }
5379
5380         tester_print("Add Advertising setup complete (instance %d)",
5381                                                                 rp->instance);
5382
5383         cp = (struct mgmt_cp_add_advertising *) adv_param;
5384         setup_add_adv_param(cp, 2);
5385         cp->timeout = 1;
5386         cp->duration = 1;
5387
5388         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5389                                                 sizeof(adv_param), adv_param,
5390                                                 setup_add_advertising_callback,
5391                                                 NULL, NULL);
5392 }
5393
5394 static void setup_multi_adv(const void *test_data)
5395 {
5396         struct test_data *data = tester_get_data();
5397         struct mgmt_cp_add_advertising *cp;
5398         unsigned char adv_param[sizeof(*cp) + TESTER_ADD_ADV_DATA_LEN];
5399         unsigned char param[] = { 0x01 };
5400
5401         tester_print("Adding two instances with timeout 1 and duration 1");
5402
5403         cp = (struct mgmt_cp_add_advertising *) adv_param;
5404         setup_add_adv_param(cp, 1);
5405         cp->timeout = 1;
5406         cp->duration = 1;
5407
5408         mgmt_send(data->mgmt, MGMT_OP_SET_LE, data->mgmt_index,
5409                                                 sizeof(param), &param,
5410                                                 NULL, NULL, NULL);
5411
5412         mgmt_send(data->mgmt, MGMT_OP_SET_POWERED, data->mgmt_index,
5413                                                 sizeof(param), &param,
5414                                                 NULL, NULL, NULL);
5415
5416         mgmt_send(data->mgmt, MGMT_OP_ADD_ADVERTISING, data->mgmt_index,
5417                                                 sizeof(adv_param), adv_param,
5418                                                 setup_multi_adv_second_instance,
5419                                                 NULL, NULL);
5420 }
5421
5422 static void setup_complete(uint8_t status, uint16_t length,
5423                                         const void *param, void *user_data)
5424 {
5425         struct test_data *data = tester_get_data();
5426
5427         if (status != MGMT_STATUS_SUCCESS) {
5428                 tester_setup_failed();
5429                 return;
5430         }
5431
5432         tester_print("Initial settings completed");
5433
5434         if (data->test_setup)
5435                 data->test_setup(data);
5436         else
5437                 setup_bthost();
5438 }
5439
5440 static void pin_code_request_callback(uint16_t index, uint16_t length,
5441                                         const void *param, void *user_data)
5442 {
5443         const struct mgmt_ev_pin_code_request *ev = param;
5444         struct test_data *data = user_data;
5445         const struct generic_data *test = data->test_data;
5446         struct mgmt_cp_pin_code_reply cp;
5447
5448         test_condition_complete(data);
5449
5450         memset(&cp, 0, sizeof(cp));
5451         memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
5452
5453         if (!test->pin) {
5454                 mgmt_reply(data->mgmt, MGMT_OP_PIN_CODE_NEG_REPLY,
5455                                 data->mgmt_index, sizeof(cp.addr), &cp.addr,
5456                                 NULL, NULL, NULL);
5457                 return;
5458         }
5459
5460         cp.pin_len = test->pin_len;
5461         memcpy(cp.pin_code, test->pin, test->pin_len);
5462
5463         mgmt_reply(data->mgmt, MGMT_OP_PIN_CODE_REPLY, data->mgmt_index,
5464                         sizeof(cp), &cp, NULL, NULL, NULL);
5465 }
5466
5467 static void user_confirm_request_callback(uint16_t index, uint16_t length,
5468                                                         const void *param,
5469                                                         void *user_data)
5470 {
5471         const struct mgmt_ev_user_confirm_request *ev = param;
5472         struct test_data *data = user_data;
5473         const struct generic_data *test = data->test_data;
5474         struct mgmt_cp_user_confirm_reply cp;
5475         uint16_t opcode;
5476
5477         if (test->just_works) {
5478                 tester_warn("User Confirmation received for just-works case");
5479                 tester_test_failed();
5480                 return;
5481         }
5482
5483         memset(&cp, 0, sizeof(cp));
5484         memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
5485
5486         if (test->reject_confirm)
5487                 opcode = MGMT_OP_USER_CONFIRM_NEG_REPLY;
5488         else
5489                 opcode = MGMT_OP_USER_CONFIRM_REPLY;
5490
5491         mgmt_reply(data->mgmt, opcode, data->mgmt_index, sizeof(cp), &cp,
5492                                                         NULL, NULL, NULL);
5493 }
5494
5495 static void user_passkey_request_callback(uint16_t index, uint16_t length,
5496                                                         const void *param,
5497                                                         void *user_data)
5498 {
5499         const struct mgmt_ev_user_passkey_request *ev = param;
5500         struct test_data *data = user_data;
5501         const struct generic_data *test = data->test_data;
5502         struct mgmt_cp_user_passkey_reply cp;
5503
5504         if (test->just_works) {
5505                 tester_warn("User Passkey Request for just-works case");
5506                 tester_test_failed();
5507                 return;
5508         }
5509
5510         memset(&cp, 0, sizeof(cp));
5511         memcpy(&cp.addr, &ev->addr, sizeof(cp.addr));
5512
5513         if (test->reject_confirm) {
5514                 mgmt_reply(data->mgmt, MGMT_OP_USER_PASSKEY_NEG_REPLY,
5515                                 data->mgmt_index, sizeof(cp.addr), &cp.addr,
5516                                 NULL, NULL, NULL);
5517                 return;
5518         }
5519
5520         mgmt_reply(data->mgmt, MGMT_OP_USER_PASSKEY_REPLY, data->mgmt_index,
5521                                         sizeof(cp), &cp, NULL, NULL, NULL);
5522 }
5523
5524 static void test_setup(const void *test_data)
5525 {
5526         struct test_data *data = tester_get_data();
5527         const struct generic_data *test = data->test_data;
5528         struct bthost *bthost = hciemu_client_get_host(data->hciemu);
5529         const uint16_t *cmd;
5530
5531         if (!test)
5532                 goto proceed;
5533
5534         if (test->pin || test->expect_pin) {
5535                 mgmt_register(data->mgmt, MGMT_EV_PIN_CODE_REQUEST,
5536                                 data->mgmt_index, pin_code_request_callback,
5537                                 data, NULL);
5538                 test_add_condition(data);
5539         }
5540
5541         mgmt_register(data->mgmt, MGMT_EV_USER_CONFIRM_REQUEST,
5542                         data->mgmt_index, user_confirm_request_callback,
5543                         data, NULL);
5544
5545         mgmt_register(data->mgmt, MGMT_EV_USER_PASSKEY_REQUEST,
5546                         data->mgmt_index, user_passkey_request_callback,
5547                         data, NULL);
5548
5549         if (test->client_pin)
5550                 bthost_set_pin_code(bthost, test->client_pin,
5551                                                         test->client_pin_len);
5552
5553         if (test->client_io_cap)
5554                 bthost_set_io_capability(bthost, test->client_io_cap);
5555
5556         if (test->client_auth_req)
5557                 bthost_set_auth_req(bthost, test->client_auth_req);
5558         else if (!test->just_works)
5559                 bthost_set_auth_req(bthost, 0x01);
5560
5561         if (test->client_reject_confirm)
5562                 bthost_set_reject_user_confirm(bthost, true);
5563
5564         if (test->client_enable_le)
5565                 bthost_write_le_host_supported(bthost, 0x01);
5566
5567         if (test->client_enable_sc)
5568                 bthost_set_sc_support(bthost, 0x01);
5569
5570 proceed:
5571         if (!test || !test->setup_settings) {
5572                 if (data->test_setup)
5573                         data->test_setup(data);
5574                 else
5575                         tester_setup_complete();
5576                 return;
5577         }
5578
5579         for (cmd = test->setup_settings; *cmd; cmd++) {
5580                 unsigned char simple_param[] = { 0x01 };
5581                 unsigned char discov_param[] = { 0x01, 0x00, 0x00 };
5582                 unsigned char privacy_param[] = { 0x01,
5583                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
5584                         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
5585                 unsigned char *param = simple_param;
5586                 size_t param_size = sizeof(simple_param);
5587                 mgmt_request_func_t func = NULL;
5588
5589                 /* If this is the last command (next one is 0) request
5590                  * for a callback. */
5591                 if (!cmd[1])
5592                         func = setup_complete;
5593
5594                 if (*cmd == MGMT_OP_SET_DISCOVERABLE) {
5595                         if (test->setup_limited_discov) {
5596                                 discov_param[0] = 0x02;
5597                                 discov_param[1] = 0x01;
5598                         }
5599                         param_size = sizeof(discov_param);
5600                         param = discov_param;
5601                 }
5602
5603                 if (*cmd == MGMT_OP_SET_PRIVACY) {
5604                         param_size = sizeof(privacy_param);
5605                         param = privacy_param;
5606                 }
5607
5608                 if (*cmd == MGMT_OP_SET_LE && test->setup_nobredr) {
5609                         unsigned char off[] = { 0x00 };
5610                         mgmt_send(data->mgmt, *cmd, data->mgmt_index,
5611                                         param_size, param, NULL, NULL, NULL);
5612                         mgmt_send(data->mgmt, MGMT_OP_SET_BREDR,
5613                                         data->mgmt_index, sizeof(off), off,
5614                                         func, data, NULL);
5615                 } else {
5616                         mgmt_send(data->mgmt, *cmd, data->mgmt_index,
5617                                         param_size, param, func, data, NULL);
5618                 }
5619         }
5620 }
5621
5622 static void command_generic_new_settings(uint16_t index, uint16_t length,
5623                                         const void *param, void *user_data)
5624 {
5625         struct test_data *data = tester_get_data();
5626
5627         tester_print("New settings event received");
5628
5629         mgmt_unregister(data->mgmt, data->mgmt_settings_id);
5630
5631         tester_test_failed();
5632 }
5633
5634 static void command_generic_new_settings_alt(uint16_t index, uint16_t length,
5635                                         const void *param, void *user_data)
5636 {
5637         struct test_data *data = tester_get_data();
5638         const struct generic_data *test = data->test_data;
5639         uint32_t settings;
5640
5641         if (length != 4) {
5642                 tester_warn("Invalid parameter size for new settings event");
5643                 tester_test_failed();
5644                 return;
5645         }
5646
5647         settings = get_le32(param);
5648
5649         tester_print("New settings 0x%08x received", settings);
5650
5651         if (test->expect_settings_unset) {
5652                 if ((settings & test->expect_settings_unset) != 0)
5653                         return;
5654                 goto done;
5655         }
5656
5657         if (!test->expect_settings_set)
5658                 return;
5659
5660         if ((settings & test->expect_settings_set) != test->expect_settings_set)
5661                 return;
5662
5663 done:
5664         tester_print("Unregistering new settings notification");
5665
5666         mgmt_unregister(data->mgmt_alt, data->mgmt_alt_settings_id);
5667
5668         test_condition_complete(data);
5669 }
5670
5671 static bool verify_alt_ev(const void *param, uint16_t length)
5672 {
5673         struct test_data *data = tester_get_data();
5674         const struct generic_data *test = data->test_data;
5675
5676         if (length != test->expect_alt_ev_len) {
5677                 tester_warn("Invalid length %u != %u", length,
5678                                                 test->expect_alt_ev_len);
5679                 return false;
5680         }
5681
5682         if (test->expect_alt_ev_param &&
5683                         memcmp(test->expect_alt_ev_param, param, length)) {
5684                 tester_warn("Event parameters do not match");
5685                 return false;
5686         }
5687
5688         return true;
5689 }
5690
5691 static void command_generic_event_alt(uint16_t index, uint16_t length,
5692                                                         const void *param,
5693                                                         void *user_data)
5694 {
5695         struct test_data *data = tester_get_data();
5696         const struct generic_data *test = data->test_data;
5697         bool (*verify)(const void *param, uint16_t length);
5698
5699         tester_print("New %s event received", mgmt_evstr(test->expect_alt_ev));
5700
5701         mgmt_unregister(data->mgmt_alt, data->mgmt_alt_ev_id);
5702
5703         if (test->verify_alt_ev_func)
5704                 verify = test->verify_alt_ev_func;
5705         else
5706                 verify = verify_alt_ev;
5707
5708         if (!verify(param, length)) {
5709                 tester_warn("Incorrect %s event parameters",
5710                                         mgmt_evstr(test->expect_alt_ev));
5711                 tester_test_failed();
5712                 return;
5713         }
5714
5715         test_condition_complete(data);
5716 }
5717
5718 static void command_generic_callback(uint8_t status, uint16_t length,
5719                                         const void *param, void *user_data)
5720 {
5721         struct test_data *data = tester_get_data();
5722         const struct generic_data *test = data->test_data;
5723         const void *expect_param = test->expect_param;
5724         uint16_t expect_len = test->expect_len;
5725
5726         tester_print("%s (0x%04x): %s (0x%02x)", mgmt_opstr(test->send_opcode),
5727                         test->send_opcode, mgmt_errstr(status), status);
5728
5729         if (status != test->expect_status) {
5730                 tester_test_failed();
5731                 return;
5732         }
5733
5734         if (!test->expect_ignore_param) {
5735                 if (test->expect_func)
5736                         expect_param = test->expect_func(&expect_len);
5737
5738                 if (length != expect_len) {
5739                         tester_warn("Invalid cmd response parameter size");
5740                         tester_test_failed();
5741                         return;
5742                 }
5743
5744                 if (expect_param && expect_len > 0 &&
5745                                         memcmp(param, expect_param, length)) {
5746                         tester_warn("Unexpected cmd response parameter value");
5747                         tester_test_failed();
5748                         return;
5749                 }
5750         }
5751
5752         test_condition_complete(data);
5753 }
5754
5755 static void command_hci_callback(uint16_t opcode, const void *param,
5756                                         uint8_t length, void *user_data)
5757 {
5758         struct test_data *data = user_data;
5759         const struct generic_data *test = data->test_data;
5760         const void *expect_hci_param = test->expect_hci_param;
5761         uint8_t expect_hci_len = test->expect_hci_len;
5762
5763         tester_print("HCI Command 0x%04x length %u", opcode, length);
5764
5765         if (opcode != test->expect_hci_command)
5766                 return;
5767
5768         if (test->expect_hci_func)
5769                 expect_hci_param = test->expect_hci_func(&expect_hci_len);
5770
5771         if (length != expect_hci_len) {
5772                 tester_warn("Invalid parameter size for HCI command");
5773                 tester_test_failed();
5774                 return;
5775         }
5776
5777         if (memcmp(param, expect_hci_param, length) != 0) {
5778                 tester_warn("Unexpected HCI command parameter value");
5779                 tester_test_failed();
5780                 return;
5781         }
5782
5783         test_condition_complete(data);
5784 }
5785
5786 static bool power_off(uint16_t index)
5787 {
5788         int sk, err;
5789
5790         sk = hci_open_dev(index);
5791         if (sk < 0)
5792                 return false;
5793
5794         err = ioctl(sk, HCIDEVDOWN, index);
5795
5796         hci_close_dev(sk);
5797
5798         if (err < 0)
5799                 return false;
5800
5801         return true;
5802 }
5803
5804 static void test_command_generic(const void *test_data)
5805 {
5806         struct test_data *data = tester_get_data();
5807         const struct generic_data *test = data->test_data;
5808         const void *send_param = test->send_param;
5809         uint16_t send_len = test->send_len;
5810         unsigned int id;
5811         uint16_t index;
5812
5813         index = test->send_index_none ? MGMT_INDEX_NONE : data->mgmt_index;
5814
5815         if (test->expect_settings_set || test->expect_settings_unset) {
5816                 tester_print("Registering new settings notification");
5817
5818                 id = mgmt_register(data->mgmt, MGMT_EV_NEW_SETTINGS, index,
5819                                 command_generic_new_settings, NULL, NULL);
5820                 data->mgmt_settings_id = id;
5821
5822                 id = mgmt_register(data->mgmt_alt, MGMT_EV_NEW_SETTINGS, index,
5823                                 command_generic_new_settings_alt, NULL, NULL);
5824                 data->mgmt_alt_settings_id = id;
5825                 test_add_condition(data);
5826         }
5827
5828         if (test->expect_alt_ev) {
5829                 tester_print("Registering %s notification",
5830                                         mgmt_evstr(test->expect_alt_ev));
5831                 id = mgmt_register(data->mgmt_alt, test->expect_alt_ev, index,
5832                                         command_generic_event_alt, NULL, NULL);
5833                 data->mgmt_alt_ev_id = id;
5834                 test_add_condition(data);
5835         }
5836
5837         if (test->expect_hci_command) {
5838                 tester_print("Registering HCI command callback");
5839                 hciemu_add_master_post_command_hook(data->hciemu,
5840                                                 command_hci_callback, data);
5841                 test_add_condition(data);
5842         }
5843
5844         if (test->send_opcode == 0x0000) {
5845                 tester_print("Executing no-op test");
5846                 return;
5847         }
5848
5849         tester_print("Sending %s (0x%04x)", mgmt_opstr(test->send_opcode),
5850                                                         test->send_opcode);
5851
5852         if (test->send_func)
5853                 send_param = test->send_func(&send_len);
5854
5855         if (test->force_power_off) {
5856                 mgmt_send_nowait(data->mgmt, test->send_opcode, index,
5857                                         send_len, send_param,
5858                                         command_generic_callback, NULL, NULL);
5859                 power_off(data->mgmt_index);
5860         } else {
5861                 mgmt_send(data->mgmt, test->send_opcode, index, send_len,
5862                                         send_param, command_generic_callback,
5863                                         NULL, NULL);
5864         }
5865
5866         test_add_condition(data);
5867 }
5868
5869 static void check_scan(void *user_data)
5870 {
5871         struct test_data *data = tester_get_data();
5872
5873         if (hciemu_get_master_le_scan_enable(data->hciemu)) {
5874                 tester_warn("LE scan still enabled");
5875                 tester_test_failed();
5876                 return;
5877         }
5878
5879         if (hciemu_get_master_scan_enable(data->hciemu)) {
5880                 tester_warn("BR/EDR scan still enabled");
5881                 tester_test_failed();
5882                 return;
5883         }
5884
5885         test_condition_complete(data);
5886 }
5887
5888 static void test_remove_device(const void *test_data)
5889 {
5890         struct test_data *data = tester_get_data();
5891
5892         test_command_generic(test_data);
5893         tester_wait(1, check_scan, NULL);
5894         test_add_condition(data);
5895 }
5896
5897 static void test_device_found(const void *test_data)
5898 {
5899         struct test_data *data = tester_get_data();
5900         const struct generic_data *test = data->test_data;
5901         struct bthost *bthost;
5902
5903         bthost = hciemu_client_get_host(data->hciemu);
5904
5905         if ((data->hciemu_type == HCIEMU_TYPE_LE) ||
5906                                 (data->hciemu_type == HCIEMU_TYPE_BREDRLE)) {
5907                 if (test->set_adv)
5908                         bthost_set_adv_data(bthost, test->adv_data,
5909                                                         test->adv_data_len);
5910
5911                 bthost_set_adv_enable(bthost, 0x01);
5912         }
5913
5914         if (data->hciemu_type != HCIEMU_TYPE_LE)
5915                 bthost_write_scan_enable(bthost, 0x03);
5916
5917         test_command_generic(test_data);
5918 }
5919
5920 static void pairing_new_conn(uint16_t handle, void *user_data)
5921 {
5922         struct test_data *data = tester_get_data();
5923         struct bthost *bthost;
5924
5925         tester_print("New connection with handle 0x%04x", handle);
5926
5927         bthost = hciemu_client_get_host(data->hciemu);
5928
5929         bthost_request_auth(bthost, handle);
5930 }
5931
5932 static void test_pairing_acceptor(const void *test_data)
5933 {
5934         struct test_data *data = tester_get_data();
5935         const struct generic_data *test = data->test_data;
5936         const uint8_t *master_bdaddr;
5937         struct bthost *bthost;
5938         uint8_t addr_type;
5939
5940         if (test->expect_alt_ev) {
5941                 unsigned int id;
5942
5943                 tester_print("Registering %s notification",
5944                                         mgmt_evstr(test->expect_alt_ev));
5945                 id = mgmt_register(data->mgmt_alt, test->expect_alt_ev,
5946                                         data->mgmt_index,
5947                                         command_generic_event_alt, NULL, NULL);
5948                 data->mgmt_alt_ev_id = id;
5949                 test_add_condition(data);
5950         }
5951
5952         master_bdaddr = hciemu_get_master_bdaddr(data->hciemu);
5953         if (!master_bdaddr) {
5954                 tester_warn("No master bdaddr");
5955                 tester_test_failed();
5956                 return;
5957         }
5958
5959         bthost = hciemu_client_get_host(data->hciemu);
5960         bthost_set_connect_cb(bthost, pairing_new_conn, data);
5961
5962         if (data->hciemu_type == HCIEMU_TYPE_BREDRLE)
5963                 addr_type = BDADDR_BREDR;
5964         else
5965                 addr_type = BDADDR_LE_PUBLIC;
5966
5967         bthost_hci_connect(bthost, master_bdaddr, addr_type);
5968 }
5969
5970 static void connected_event(uint16_t index, uint16_t length, const void *param,
5971                                                         void *user_data)
5972 {
5973         struct test_data *data = tester_get_data();
5974         const struct generic_data *test = data->test_data;
5975         const void *send_param = test->send_param;
5976         uint16_t send_len = test->send_len;
5977
5978         tester_print("Sending %s 0x%04x", mgmt_opstr(test->send_opcode),
5979                                                         test->send_opcode);
5980
5981         if (test->send_func)
5982                 send_param = test->send_func(&send_len);
5983
5984         if (test->force_power_off) {
5985                 mgmt_send_nowait(data->mgmt, test->send_opcode, index,
5986                                         send_len, send_param,
5987                                         command_generic_callback, NULL, NULL);
5988                 power_off(data->mgmt_index);
5989         } else {
5990                 mgmt_send(data->mgmt, test->send_opcode, index, send_len,
5991                                         send_param, command_generic_callback,
5992                                         NULL, NULL);
5993         }
5994
5995         test_add_condition(data);
5996
5997         /* Complete MGMT_EV_DEVICE_CONNECTED *after* adding new one */
5998         test_condition_complete(data);
5999 }
6000
6001 static void test_command_generic_connect(const void *test_data)
6002 {
6003         struct test_data *data = tester_get_data();
6004         unsigned int id;
6005         const uint8_t *master_bdaddr;
6006         uint8_t addr_type;
6007         struct bthost *bthost;
6008
6009         tester_print("Registering %s notification",
6010                                         mgmt_evstr(MGMT_EV_DEVICE_CONNECTED));
6011         id = mgmt_register(data->mgmt_alt, MGMT_EV_DEVICE_CONNECTED,
6012                                 data->mgmt_index, connected_event,
6013                                 NULL, NULL);
6014         data->mgmt_alt_ev_id = id;
6015         test_add_condition(data);
6016
6017         master_bdaddr = hciemu_get_master_bdaddr(data->hciemu);
6018         if (!master_bdaddr) {
6019                 tester_warn("No master bdaddr");
6020                 tester_test_failed();
6021                 return;
6022         }
6023
6024         addr_type = data->hciemu_type == HCIEMU_TYPE_BREDRLE ? BDADDR_BREDR :
6025                                                         BDADDR_LE_PUBLIC;
6026
6027         bthost = hciemu_client_get_host(data->hciemu);
6028         bthost_hci_connect(bthost, master_bdaddr, addr_type);
6029 }
6030
6031 int main(int argc, char *argv[])
6032 {
6033         tester_init(&argc, &argv);
6034
6035         test_bredrle("Controller setup",
6036                                 NULL, NULL, controller_setup);
6037         test_bredr("Controller setup (BR/EDR-only)",
6038                                 NULL, NULL, controller_setup);
6039         test_le("Controller setup (LE)",
6040                                 NULL, NULL, controller_setup);
6041
6042         test_bredrle("Invalid command",
6043                                 &invalid_command_test,
6044                                 NULL, test_command_generic);
6045
6046         test_bredrle("Read version - Success",
6047                                 &read_version_success_test,
6048                                 NULL, test_command_generic);
6049         test_bredrle("Read version - Invalid parameters",
6050                                 &read_version_invalid_param_test,
6051                                 NULL, test_command_generic);
6052         test_bredrle("Read version - Invalid index",
6053                                 &read_version_invalid_index_test,
6054                                 NULL, test_command_generic);
6055         test_bredrle("Read commands - Invalid parameters",
6056                                 &read_commands_invalid_param_test,
6057                                 NULL, test_command_generic);
6058         test_bredrle("Read commands - Invalid index",
6059                                 &read_commands_invalid_index_test,
6060                                 NULL, test_command_generic);
6061         test_bredrle("Read index list - Invalid parameters",
6062                                 &read_index_list_invalid_param_test,
6063                                 NULL, test_command_generic);
6064         test_bredrle("Read index list - Invalid index",
6065                                 &read_index_list_invalid_index_test,
6066                                 NULL, test_command_generic);
6067         test_bredrle("Read info - Invalid parameters",
6068                                 &read_info_invalid_param_test,
6069                                 NULL, test_command_generic);
6070         test_bredrle("Read info - Invalid index",
6071                                 &read_info_invalid_index_test,
6072                                 NULL, test_command_generic);
6073         test_bredrle("Read unconfigured index list - Invalid parameters",
6074                                 &read_unconf_index_list_invalid_param_test,
6075                                 NULL, test_command_generic);
6076         test_bredrle("Read unconfigured index list - Invalid index",
6077                                 &read_unconf_index_list_invalid_index_test,
6078                                 NULL, test_command_generic);
6079         test_bredrle("Read configuration info - Invalid parameters",
6080                                 &read_config_info_invalid_param_test,
6081                                 NULL, test_command_generic);
6082         test_bredrle("Read configuration info - Invalid index",
6083                                 &read_config_info_invalid_index_test,
6084                                 NULL, test_command_generic);
6085         test_bredrle("Read extended index list - Invalid parameters",
6086                                 &read_ext_index_list_invalid_param_test,
6087                                 NULL, test_command_generic);
6088         test_bredrle("Read extended index list - Invalid index",
6089                                 &read_ext_index_list_invalid_index_test,
6090                                 NULL, test_command_generic);
6091
6092         test_bredrle("Set powered on - Success",
6093                                 &set_powered_on_success_test,
6094                                 NULL, test_command_generic);
6095         test_bredrle("Set powered on - Invalid parameters 1",
6096                                 &set_powered_on_invalid_param_test_1,
6097                                 NULL, test_command_generic);
6098         test_bredrle("Set powered on - Invalid parameters 2",
6099                                 &set_powered_on_invalid_param_test_2,
6100                                 NULL, test_command_generic);
6101         test_bredrle("Set powered on - Invalid parameters 3",
6102                                 &set_powered_on_invalid_param_test_3,
6103                                 NULL, test_command_generic);
6104         test_bredrle("Set powered on - Invalid index",
6105                                 &set_powered_on_invalid_index_test,
6106                                 NULL, test_command_generic);
6107         test_le("Set powered on - Privacy and Advertising",
6108                                 &set_powered_on_privacy_adv_test,
6109                                 NULL, test_command_generic);
6110
6111         test_bredrle("Set powered off - Success",
6112                                 &set_powered_off_success_test,
6113                                 NULL, test_command_generic);
6114         test_bredrle("Set powered off - Class of Device",
6115                                 &set_powered_off_class_test,
6116                                 setup_class, test_command_generic);
6117         test_bredrle("Set powered off - Invalid parameters 1",
6118                                 &set_powered_off_invalid_param_test_1,
6119                                 NULL, test_command_generic);
6120         test_bredrle("Set powered off - Invalid parameters 2",
6121                                 &set_powered_off_invalid_param_test_2,
6122                                 NULL, test_command_generic);
6123         test_bredrle("Set powered off - Invalid parameters 3",
6124                                 &set_powered_off_invalid_param_test_3,
6125                                 NULL, test_command_generic);
6126
6127         test_bredrle("Set connectable on - Success 1",
6128                                 &set_connectable_on_success_test_1,
6129                                 NULL, test_command_generic);
6130         test_bredrle("Set connectable on - Success 2",
6131                                 &set_connectable_on_success_test_2,
6132                                 NULL, test_command_generic);
6133         test_bredrle("Set connectable on - Invalid parameters 1",
6134                                 &set_connectable_on_invalid_param_test_1,
6135                                 NULL, test_command_generic);
6136         test_bredrle("Set connectable on - Invalid parameters 2",
6137                                 &set_connectable_on_invalid_param_test_2,
6138                                 NULL, test_command_generic);
6139         test_bredrle("Set connectable on - Invalid parameters 3",
6140                                 &set_connectable_on_invalid_param_test_3,
6141                                 NULL, test_command_generic);
6142         test_bredrle("Set connectable on - Invalid index",
6143                                 &set_connectable_on_invalid_index_test,
6144                                 NULL, test_command_generic);
6145
6146         test_le("Set connectable on (LE) - Success 1",
6147                                 &set_connectable_on_le_test_1,
6148                                 NULL, test_command_generic);
6149         test_le("Set connectable on (LE) - Success 2",
6150                                 &set_connectable_on_le_test_2,
6151                                 NULL, test_command_generic);
6152         test_le("Set connectable on (LE) - Success 3",
6153                                 &set_connectable_on_le_test_3,
6154                                 NULL, test_command_generic);
6155
6156         test_bredrle("Set connectable off - Success 1",
6157                                 &set_connectable_off_success_test_1,
6158                                 NULL, test_command_generic);
6159         test_bredrle("Set connectable off - Success 2",
6160                                 &set_connectable_off_success_test_2,
6161                                 NULL, test_command_generic);
6162         test_bredrle("Set connectable off - Success 3",
6163                                 &set_connectable_off_success_test_3,
6164                                 NULL, test_command_generic);
6165         test_bredrle("Set connectable off - Success 4",
6166                                 &set_connectable_off_success_test_4,
6167                                 setup_add_device, test_command_generic);
6168
6169         test_le("Set connectable off (LE) - Success 1",
6170                                 &set_connectable_off_le_test_1,
6171                                 NULL, test_command_generic);
6172         test_le("Set connectable off (LE) - Success 2",
6173                                 &set_connectable_off_le_test_2,
6174                                 NULL, test_command_generic);
6175         test_le("Set connectable off (LE) - Success 3",
6176                                 &set_connectable_off_le_test_3,
6177                                 NULL, test_command_generic);
6178         test_le("Set connectable off (LE) - Success 4",
6179                                 &set_connectable_off_le_test_4,
6180                                 NULL, test_command_generic);
6181
6182         test_bredrle("Set fast connectable on - Success 1",
6183                                 &set_fast_conn_on_success_test_1,
6184                                 NULL, test_command_generic);
6185         test_bredrle("Set fast connectable on - Success 2",
6186                                 &set_fast_conn_on_success_test_2,
6187                                 NULL, test_command_generic);
6188         test_bredrle("Set fast connectable on - Success 3",
6189                                 &set_fast_conn_on_success_test_3,
6190                                 NULL, test_command_generic);
6191         test_bredrle("Set fast connectable on - Invalid Params 1",
6192                                 &set_fast_conn_nval_param_test_1,
6193                                 NULL, test_command_generic);
6194         test_le("Set fast connectable on - Not Supported 1",
6195                                 &set_fast_conn_on_not_supported_test_1,
6196                                 NULL, test_command_generic);
6197
6198         test_bredrle("Set bondable on - Success",
6199                                 &set_bondable_on_success_test,
6200                                 NULL, test_command_generic);
6201         test_bredrle("Set bondable on - Invalid parameters 1",
6202                                 &set_bondable_on_invalid_param_test_1,
6203                                 NULL, test_command_generic);
6204         test_bredrle("Set bondable on - Invalid parameters 2",
6205                                 &set_bondable_on_invalid_param_test_2,
6206                                 NULL, test_command_generic);
6207         test_bredrle("Set bondable on - Invalid parameters 3",
6208                                 &set_bondable_on_invalid_param_test_3,
6209                                 NULL, test_command_generic);
6210         test_bredrle("Set bondable on - Invalid index",
6211                                 &set_bondable_on_invalid_index_test,
6212                                 NULL, test_command_generic);
6213
6214         test_bredrle("Set discoverable on - Invalid parameters 1",
6215                                 &set_discoverable_on_invalid_param_test_1,
6216                                 NULL, test_command_generic);
6217         test_bredrle("Set discoverable on - Invalid parameters 2",
6218                                 &set_discoverable_on_invalid_param_test_2,
6219                                 NULL, test_command_generic);
6220         test_bredrle("Set discoverable on - Invalid parameters 3",
6221                                 &set_discoverable_on_invalid_param_test_3,
6222                                 NULL, test_command_generic);
6223         test_bredrle("Set discoverable on - Invalid parameters 4",
6224                                 &set_discoverable_on_invalid_param_test_4,
6225                                 NULL, test_command_generic);
6226         test_bredrle("Set discoverable on - Not powered 1",
6227                                 &set_discoverable_on_not_powered_test_1,
6228                                 NULL, test_command_generic);
6229         test_bredrle("Set discoverable on - Not powered 2",
6230                                 &set_discoverable_on_not_powered_test_2,
6231                                 NULL, test_command_generic);
6232         test_bredrle("Set discoverable on - Rejected 1",
6233                                 &set_discoverable_on_rejected_test_1,
6234                                 NULL, test_command_generic);
6235         test_bredrle("Set discoverable on - Rejected 2",
6236                                 &set_discoverable_on_rejected_test_2,
6237                                 NULL, test_command_generic);
6238         test_bredrle("Set discoverable on - Rejected 3",
6239                                 &set_discoverable_on_rejected_test_3,
6240                                 NULL, test_command_generic);
6241         test_bredrle("Set discoverable on - Success 1",
6242                                 &set_discoverable_on_success_test_1,
6243                                 NULL, test_command_generic);
6244         test_bredrle("Set discoverable on - Success 2",
6245                                 &set_discoverable_on_success_test_2,
6246                                 NULL, test_command_generic);
6247         test_le("Set discoverable on (LE) - Success 1",
6248                                 &set_discov_on_le_success_1,
6249                                 NULL, test_command_generic);
6250         test_bredrle("Set discoverable off - Success 1",
6251                                 &set_discoverable_off_success_test_1,
6252                                 NULL, test_command_generic);
6253         test_bredrle("Set discoverable off - Success 2",
6254                                 &set_discoverable_off_success_test_2,
6255                                 NULL, test_command_generic);
6256         test_bredrle("Set limited discoverable on - Success 1",
6257                                 &set_limited_discov_on_success_1,
6258                                 NULL, test_command_generic);
6259         test_bredrle("Set limited discoverable on - Success 2",
6260                                 &set_limited_discov_on_success_2,
6261                                 NULL, test_command_generic);
6262         test_bredrle("Set limited discoverable on - Success 3",
6263                                 &set_limited_discov_on_success_3,
6264                                 NULL, test_command_generic);
6265         test_le("Set limited discoverable on (LE) - Success 1",
6266                                 &set_limited_discov_on_le_success_1,
6267                                 NULL, test_command_generic);
6268
6269         test_bredrle("Set link security on - Success 1",
6270                                 &set_link_sec_on_success_test_1,
6271                                 NULL, test_command_generic);
6272         test_bredrle("Set link security on - Success 2",
6273                                 &set_link_sec_on_success_test_2,
6274                                 NULL, test_command_generic);
6275         test_bredrle("Set link security on - Success 3",
6276                                 &set_link_sec_on_success_test_3,
6277                                 NULL, test_command_generic);
6278         test_bredrle("Set link security on - Invalid parameters 1",
6279                                 &set_link_sec_on_invalid_param_test_1,
6280                                 NULL, test_command_generic);
6281         test_bredrle("Set link security on - Invalid parameters 2",
6282                                 &set_link_sec_on_invalid_param_test_2,
6283                                 NULL, test_command_generic);
6284         test_bredrle("Set link security on - Invalid parameters 3",
6285                                 &set_link_sec_on_invalid_param_test_3,
6286                                 NULL, test_command_generic);
6287         test_bredrle("Set link security on - Invalid index",
6288                                 &set_link_sec_on_invalid_index_test,
6289                                 NULL, test_command_generic);
6290
6291         test_bredrle("Set link security off - Success 1",
6292                                 &set_link_sec_off_success_test_1,
6293                                 NULL, test_command_generic);
6294         test_bredrle("Set link security off - Success 2",
6295                                 &set_link_sec_off_success_test_2,
6296                                 NULL, test_command_generic);
6297
6298         test_bredrle("Set SSP on - Success 1",
6299                                 &set_ssp_on_success_test_1,
6300                                 NULL, test_command_generic);
6301         test_bredrle("Set SSP on - Success 2",
6302                                 &set_ssp_on_success_test_2,
6303                                 NULL, test_command_generic);
6304         test_bredrle("Set SSP on - Success 3",
6305                                 &set_ssp_on_success_test_3,
6306                                 NULL, test_command_generic);
6307         test_bredrle("Set SSP on - Invalid parameters 1",
6308                                 &set_ssp_on_invalid_param_test_1,
6309                                 NULL, test_command_generic);
6310         test_bredrle("Set SSP on - Invalid parameters 2",
6311                                 &set_ssp_on_invalid_param_test_2,
6312                                 NULL, test_command_generic);
6313         test_bredrle("Set SSP on - Invalid parameters 3",
6314                                 &set_ssp_on_invalid_param_test_3,
6315                                 NULL, test_command_generic);
6316         test_bredrle("Set SSP on - Invalid index",
6317                                 &set_ssp_on_invalid_index_test,
6318                                 NULL, test_command_generic);
6319
6320         test_bredrle("Set Secure Connections on - Success 1",
6321                                 &set_sc_on_success_test_1,
6322                                 NULL, test_command_generic);
6323         test_bredrle("Set Secure Connections on - Success 2",
6324                                 &set_sc_on_success_test_2,
6325                                 NULL, test_command_generic);
6326         test_bredrle("Set Secure Connections on - Invalid params 1",
6327                                 &set_sc_on_invalid_param_test_1,
6328                                 NULL, test_command_generic);
6329         test_bredrle("Set Secure Connections on - Invalid params 2",
6330                                 &set_sc_on_invalid_param_test_2,
6331                                 NULL, test_command_generic);
6332         test_bredrle("Set Secure Connections on - Invalid params 3",
6333                                 &set_sc_on_invalid_param_test_3,
6334                                 NULL, test_command_generic);
6335         test_bredrle("Set Secure Connections on - Invalid index",
6336                                 &set_sc_on_invalid_index_test,
6337                                 NULL, test_command_generic);
6338         test_bredr("Set Secure Connections on - Not supported 1",
6339                                 &set_sc_on_not_supported_test_1,
6340                                 NULL, test_command_generic);
6341         test_bredr("Set Secure Connections on - Not supported 2",
6342                                 &set_sc_on_not_supported_test_2,
6343                                 NULL, test_command_generic);
6344
6345         test_bredrle("Set Secure Connections Only on - Success 1",
6346                                 &set_sc_only_on_success_test_1,
6347                                 NULL, test_command_generic);
6348         test_bredrle("Set Secure Connections Only on - Success 2",
6349                                 &set_sc_only_on_success_test_2,
6350                                 NULL, test_command_generic);
6351
6352         test_bredrle("Set High Speed on - Success",
6353                                 &set_hs_on_success_test,
6354                                 NULL, test_command_generic);
6355         test_bredrle("Set High Speed on - Invalid parameters 1",
6356                                 &set_hs_on_invalid_param_test_1,
6357                                 NULL, test_command_generic);
6358         test_bredrle("Set High Speed on - Invalid parameters 2",
6359                                 &set_hs_on_invalid_param_test_2,
6360                                 NULL, test_command_generic);
6361         test_bredrle("Set High Speed on - Invalid parameters 3",
6362                                 &set_hs_on_invalid_param_test_3,
6363                                 NULL, test_command_generic);
6364         test_bredrle("Set High Speed on - Invalid index",
6365                                 &set_hs_on_invalid_index_test,
6366                                 NULL, test_command_generic);
6367
6368         test_bredrle("Set Low Energy on - Success 1",
6369                                 &set_le_on_success_test_1,
6370                                 NULL, test_command_generic);
6371         test_bredrle("Set Low Energy on - Success 2",
6372                                 &set_le_on_success_test_2,
6373                                 NULL, test_command_generic);
6374         test_bredrle("Set Low Energy on - Success 3",
6375                                 &set_le_on_success_test_3,
6376                                 NULL, test_command_generic);
6377         test_bredrle("Set Low Energy on - Invalid parameters 1",
6378                                 &set_le_on_invalid_param_test_1,
6379                                 NULL, test_command_generic);
6380         test_bredrle("Set Low Energy on - Invalid parameters 2",
6381                                 &set_le_on_invalid_param_test_2,
6382                                 NULL, test_command_generic);
6383         test_bredrle("Set Low Energy on - Invalid parameters 3",
6384                                 &set_le_on_invalid_param_test_3,
6385                                 NULL, test_command_generic);
6386         test_bredrle("Set Low Energy on - Invalid index",
6387                                 &set_le_on_invalid_index_test,
6388                                 NULL, test_command_generic);
6389
6390         test_bredrle("Set Advertising on - Success 1",
6391                                 &set_adv_on_success_test_1,
6392                                 NULL, test_command_generic);
6393         test_bredrle("Set Advertising on - Success 2",
6394                                 &set_adv_on_success_test_2,
6395                                 NULL, test_command_generic);
6396         test_bredrle("Set Advertising on - Rejected 1",
6397                                 &set_adv_on_rejected_test_1,
6398                                 NULL, test_command_generic);
6399
6400         test_bredrle("Set BR/EDR off - Success 1",
6401                                 &set_bredr_off_success_test_1,
6402                                 NULL, test_command_generic);
6403         test_bredrle("Set BR/EDR on - Success 1",
6404                                 &set_bredr_on_success_test_1,
6405                                 NULL, test_command_generic);
6406         test_bredrle("Set BR/EDR on - Success 2",
6407                                 &set_bredr_on_success_test_2,
6408                                 NULL, test_command_generic);
6409         test_bredr("Set BR/EDR off - Not Supported 1",
6410                                 &set_bredr_off_notsupp_test,
6411                                 NULL, test_command_generic);
6412         test_le("Set BR/EDR off - Not Supported 2",
6413                                 &set_bredr_off_notsupp_test,
6414                                 NULL, test_command_generic);
6415         test_bredrle("Set BR/EDR off - Rejected 1",
6416                                 &set_bredr_off_failure_test_1,
6417                                 NULL, test_command_generic);
6418         test_bredrle("Set BR/EDR off - Rejected 2",
6419                                 &set_bredr_off_failure_test_2,
6420                                 NULL, test_command_generic);
6421         test_bredrle("Set BR/EDR off - Invalid Parameters 1",
6422                                 &set_bredr_off_failure_test_3,
6423                                 NULL, test_command_generic);
6424
6425         test_bredr("Set Local Name - Success 1",
6426                                 &set_local_name_test_1,
6427                                 NULL, test_command_generic);
6428         test_bredr("Set Local Name - Success 2",
6429                                 &set_local_name_test_2,
6430                                 NULL, test_command_generic);
6431         test_bredr("Set Local Name - Success 3",
6432                                 &set_local_name_test_3,
6433                                 NULL, test_command_generic);
6434
6435         test_bredrle("Start Discovery - Not powered 1",
6436                                 &start_discovery_not_powered_test_1,
6437                                 NULL, test_command_generic);
6438         test_bredrle("Start Discovery - Invalid parameters 1",
6439                                 &start_discovery_invalid_param_test_1,
6440                                 NULL, test_command_generic);
6441         test_bredrle("Start Discovery - Not supported 1",
6442                                 &start_discovery_not_supported_test_1,
6443                                 NULL, test_command_generic);
6444         test_bredrle("Start Discovery - Success 1",
6445                                 &start_discovery_valid_param_test_1,
6446                                 NULL, test_command_generic);
6447         test_le("Start Discovery - Success 2",
6448                                 &start_discovery_valid_param_test_2,
6449                                 NULL, test_command_generic);
6450         test_bredrle("Start Discovery - Power Off 1",
6451                                 &start_discovery_valid_param_power_off_1,
6452                                 NULL, test_command_generic);
6453
6454         test_bredrle("Stop Discovery - Success 1",
6455                                 &stop_discovery_success_test_1,
6456                                 setup_start_discovery, test_command_generic);
6457         test_bredr("Stop Discovery - BR/EDR (Inquiry) Success 1",
6458                                 &stop_discovery_bredr_success_test_1,
6459                                 setup_start_discovery, test_command_generic);
6460         test_bredrle("Stop Discovery - Rejected 1",
6461                                 &stop_discovery_rejected_test_1,
6462                                 NULL, test_command_generic);
6463         test_bredrle("Stop Discovery - Invalid parameters 1",
6464                                 &stop_discovery_invalid_param_test_1,
6465                                 setup_start_discovery, test_command_generic);
6466
6467         test_bredrle("Start Service Discovery - Not powered 1",
6468                                 &start_service_discovery_not_powered_test_1,
6469                                 NULL, test_command_generic);
6470         test_bredrle("Start Service Discovery - Invalid parameters 1",
6471                                 &start_service_discovery_invalid_param_test_1,
6472                                 NULL, test_command_generic);
6473         test_bredrle("Start Service Discovery - Not supported 1",
6474                                 &start_service_discovery_not_supported_test_1,
6475                                 NULL, test_command_generic);
6476         test_bredrle("Start Service Discovery - Success 1",
6477                                 &start_service_discovery_valid_param_test_1,
6478                                 NULL, test_command_generic);
6479         test_le("Start Service Discovery - Success 2",
6480                                 &start_service_discovery_valid_param_test_2,
6481                                 NULL, test_command_generic);
6482
6483         test_bredrle("Set Device Class - Success 1",
6484                                 &set_dev_class_valid_param_test_1,
6485                                 NULL, test_command_generic);
6486         test_bredrle("Set Device Class - Success 2",
6487                                 &set_dev_class_valid_param_test_2,
6488                                 NULL, test_command_generic);
6489         test_bredrle("Set Device Class - Invalid parameters 1",
6490                                 &set_dev_class_invalid_param_test_1,
6491                                 NULL, test_command_generic);
6492
6493         test_bredrle("Add UUID - UUID-16 1",
6494                                 &add_uuid16_test_1,
6495                                 NULL, test_command_generic);
6496         test_bredrle("Add UUID - UUID-16 multiple 1",
6497                                 &add_multi_uuid16_test_1,
6498                                 setup_multi_uuid16, test_command_generic);
6499         test_bredrle("Add UUID - UUID-16 partial 1",
6500                                 &add_multi_uuid16_test_2,
6501                                 setup_multi_uuid16_2, test_command_generic);
6502         test_bredrle("Add UUID - UUID-32 1",
6503                                 &add_uuid32_test_1,
6504                                 NULL, test_command_generic);
6505         test_bredrle("Add UUID - UUID-32 multiple 1",
6506                                 &add_uuid32_multi_test_1,
6507                                 setup_multi_uuid32, test_command_generic);
6508         test_bredrle("Add UUID - UUID-32 partial 1",
6509                                 &add_uuid32_multi_test_2,
6510                                 setup_multi_uuid32_2, test_command_generic);
6511         test_bredrle("Add UUID - UUID-128 1",
6512                                 &add_uuid128_test_1,
6513                                 NULL, test_command_generic);
6514         test_bredrle("Add UUID - UUID-128 multiple 1",
6515                                 &add_uuid128_multi_test_1,
6516                                 setup_multi_uuid128, test_command_generic);
6517         test_bredrle("Add UUID - UUID-128 partial 1",
6518                                 &add_uuid128_multi_test_2,
6519                                 setup_multi_uuid128_2, test_command_generic);
6520         test_bredrle("Add UUID - UUID mix",
6521                                 &add_uuid_mix_test_1,
6522                                 setup_uuid_mix, test_command_generic);
6523
6524         test_bredrle("Load Link Keys - Empty List Success 1",
6525                                 &load_link_keys_success_test_1,
6526                                 NULL, test_command_generic);
6527         test_bredrle("Load Link Keys - Empty List Success 2",
6528                                 &load_link_keys_success_test_2,
6529                                 NULL, test_command_generic);
6530         test_bredrle("Load Link Keys - Invalid Parameters 1",
6531                                 &load_link_keys_invalid_params_test_1,
6532                                 NULL, test_command_generic);
6533         test_bredrle("Load Link Keys - Invalid Parameters 2",
6534                                 &load_link_keys_invalid_params_test_2,
6535                                 NULL, test_command_generic);
6536         test_bredrle("Load Link Keys - Invalid Parameters 3",
6537                                 &load_link_keys_invalid_params_test_3,
6538                                 NULL, test_command_generic);
6539
6540         test_bredrle("Load Long Term Keys - Success 1",
6541                                 &load_ltks_success_test_1,
6542                                 NULL, test_command_generic);
6543         test_bredrle("Load Long Term Keys - Invalid Parameters 1",
6544                                 &load_ltks_invalid_params_test_1,
6545                                 NULL, test_command_generic);
6546         test_bredrle("Load Long Term Keys - Invalid Parameters 2",
6547                                 &load_ltks_invalid_params_test_2,
6548                                 NULL, test_command_generic);
6549         test_bredrle("Load Long Term Keys - Invalid Parameters 3",
6550                                 &load_ltks_invalid_params_test_3,
6551                                 NULL, test_command_generic);
6552         test_bredrle("Load Long Term Keys - Invalid Parameters 4",
6553                                 &load_ltks_invalid_params_test_4,
6554                                 NULL, test_command_generic);
6555
6556         test_bredrle("Set IO Capability - Invalid Params 1",
6557                                 &set_io_cap_invalid_param_test_1,
6558                                 NULL, test_command_generic);
6559
6560         test_bredrle("Pair Device - Not Powered 1",
6561                                 &pair_device_not_powered_test_1,
6562                                 NULL, test_command_generic);
6563         test_bredrle("Pair Device - Power off 1",
6564                                 &pair_device_power_off_test_1,
6565                                 NULL, test_command_generic);
6566         test_le("Pair Device - Incorrect transport reject 1",
6567                                 &pair_device_not_supported_test_1,
6568                                 NULL, test_command_generic);
6569         test_bredr("Pair Device - Incorrect transport reject 2",
6570                                 &pair_device_not_supported_test_2,
6571                                 NULL, test_command_generic);
6572         test_bredrle("Pair Device - Reject on not enabled transport 1",
6573                                 &pair_device_reject_transport_not_enabled_1,
6574                                 NULL, test_command_generic);
6575         test_bredrle("Pair Device - Reject on not enabled transport 2",
6576                                 &pair_device_reject_transport_not_enabled_2,
6577                                 NULL, test_command_generic);
6578         test_bredrle("Pair Device - Invalid Parameters 1",
6579                                 &pair_device_invalid_param_test_1,
6580                                 NULL, test_command_generic);
6581         test_bredrle("Pair Device - Invalid Parameters 2",
6582                                 &pair_device_invalid_param_test_2,
6583                                 NULL, test_command_generic);
6584         test_bredrle("Pair Device - Legacy Success 1",
6585                                 &pair_device_success_test_1,
6586                                 NULL, test_command_generic);
6587         test_bredrle("Pair Device - Legacy Non-bondable 1",
6588                                 &pair_device_legacy_nonbondable_1,
6589                                 NULL, test_command_generic);
6590         test_bredrle("Pair Device - Sec Mode 3 Success 1",
6591                                 &pair_device_success_test_2,
6592                                 NULL, test_command_generic);
6593         test_bredrle("Pair Device - Legacy Reject 1",
6594                                 &pair_device_reject_test_1,
6595                                 NULL, test_command_generic);
6596         test_bredrle("Pair Device - Legacy Reject 2",
6597                                 &pair_device_reject_test_2,
6598                                 NULL, test_command_generic);
6599         test_bredrle("Pair Device - Sec Mode 3 Reject 1",
6600                                 &pair_device_reject_test_3,
6601                                 NULL, test_command_generic);
6602         test_bredrle("Pair Device - Sec Mode 3 Reject 2",
6603                                 &pair_device_reject_test_4,
6604                                 NULL, test_command_generic);
6605         test_bredrle("Pair Device - SSP Just-Works Success 1",
6606                                 &pair_device_ssp_test_1,
6607                                 NULL, test_command_generic);
6608         test_bredrle("Pair Device - SSP Just-Works Success 2",
6609                                 &pair_device_ssp_test_2,
6610                                 NULL, test_command_generic);
6611         test_bredrle("Pair Device - SSP Just-Works Success 3",
6612                                 &pair_device_ssp_test_3,
6613                                 NULL, test_command_generic);
6614         test_bredrle("Pair Device - SSP Confirm Success 1",
6615                                 &pair_device_ssp_test_4,
6616                                 NULL, test_command_generic);
6617         test_bredrle("Pair Device - SSP Confirm Success 2",
6618                                 &pair_device_ssp_test_5,
6619                                 NULL, test_command_generic);
6620         test_bredrle("Pair Device - SSP Confirm Success 3",
6621                                 &pair_device_ssp_test_6,
6622                                 NULL, test_command_generic);
6623         test_bredrle("Pair Device - SSP Confirm Reject 1",
6624                                 &pair_device_ssp_reject_1,
6625                                 NULL, test_command_generic);
6626         test_bredrle("Pair Device - SSP Confirm Reject 2",
6627                                 &pair_device_ssp_reject_2,
6628                                 NULL, test_command_generic);
6629         test_bredrle("Pair Device - SSP Non-bondable 1",
6630                                 &pair_device_ssp_nonbondable_1,
6631                                 NULL, test_command_generic);
6632         test_bredrle("Pair Device - SMP over BR/EDR Success 1",
6633                                 &pair_device_smp_bredr_test_1,
6634                                 NULL, test_command_generic);
6635         test_bredrle("Pair Device - SMP over BR/EDR Success 2",
6636                                 &pair_device_smp_bredr_test_2,
6637                                 NULL, test_command_generic);
6638         test_le("Pair Device - LE Success 1",
6639                                 &pair_device_le_success_test_1,
6640                                 NULL, test_command_generic);
6641         test_le("Pair Device - LE Success 2",
6642                                 &pair_device_le_success_test_2,
6643                                 NULL, test_command_generic);
6644         test_le("Pair Device - LE Reject 1",
6645                                 &pair_device_le_reject_test_1,
6646                                 NULL, test_command_generic);
6647         test_le("Pair Device - LE SC Legacy 1",
6648                                 &pair_device_le_sc_legacy_test_1,
6649                                 NULL, test_command_generic);
6650         test_le("Pair Device - LE SC Success 1",
6651                                 &pair_device_le_sc_success_test_1,
6652                                 NULL, test_command_generic);
6653         test_le("Pair Device - LE SC Success 2",
6654                                 &pair_device_le_sc_success_test_2,
6655                                 NULL, test_command_generic);
6656
6657         test_bredrle("Pairing Acceptor - Legacy 1",
6658                                 &pairing_acceptor_legacy_1, NULL,
6659                                 test_pairing_acceptor);
6660         test_bredrle("Pairing Acceptor - Legacy 2",
6661                                 &pairing_acceptor_legacy_2, NULL,
6662                                 test_pairing_acceptor);
6663         test_bredrle("Pairing Acceptor - Legacy 3",
6664                                 &pairing_acceptor_legacy_3, NULL,
6665                                 test_pairing_acceptor);
6666         test_bredrle("Pairing Acceptor - Link Sec 1",
6667                                 &pairing_acceptor_linksec_1, NULL,
6668                                 test_pairing_acceptor);
6669         test_bredrle("Pairing Acceptor - Link Sec 2",
6670                                 &pairing_acceptor_linksec_2, NULL,
6671                                 test_pairing_acceptor);
6672         test_bredrle("Pairing Acceptor - SSP 1",
6673                                 &pairing_acceptor_ssp_1, setup_pairing_acceptor,
6674                                 test_pairing_acceptor);
6675         test_bredrle("Pairing Acceptor - SSP 2",
6676                                 &pairing_acceptor_ssp_2, setup_pairing_acceptor,
6677                                 test_pairing_acceptor);
6678         test_bredrle("Pairing Acceptor - SSP 3",
6679                                 &pairing_acceptor_ssp_3, setup_pairing_acceptor,
6680                                 test_pairing_acceptor);
6681         test_bredrle("Pairing Acceptor - SSP 4",
6682                                 &pairing_acceptor_ssp_4, setup_pairing_acceptor,
6683                                 test_pairing_acceptor);
6684         test_bredrle("Pairing Acceptor - SMP over BR/EDR 1",
6685                                 &pairing_acceptor_smp_bredr_1,
6686                                 setup_pairing_acceptor, test_pairing_acceptor);
6687         test_bredrle("Pairing Acceptor - SMP over BR/EDR 2",
6688                                 &pairing_acceptor_smp_bredr_2,
6689                                 setup_pairing_acceptor, test_pairing_acceptor);
6690         test_le("Pairing Acceptor - LE 1",
6691                                 &pairing_acceptor_le_1, setup_pairing_acceptor,
6692                                 test_pairing_acceptor);
6693         test_le("Pairing Acceptor - LE 2",
6694                                 &pairing_acceptor_le_2, setup_pairing_acceptor,
6695                                 test_pairing_acceptor);
6696         test_le("Pairing Acceptor - LE 3",
6697                                 &pairing_acceptor_le_3, setup_pairing_acceptor,
6698                                 test_pairing_acceptor);
6699         test_le("Pairing Acceptor - LE 4",
6700                                 &pairing_acceptor_le_4, setup_pairing_acceptor,
6701                                 test_pairing_acceptor);
6702         test_le("Pairing Acceptor - LE 5",
6703                                 &pairing_acceptor_le_5, setup_pairing_acceptor,
6704                                 test_pairing_acceptor);
6705
6706         test_bredrle("Unpair Device - Not Powered 1",
6707                                 &unpair_device_not_powered_test_1,
6708                                 NULL, test_command_generic);
6709         test_bredrle("Unpair Device - Invalid Parameters 1",
6710                                 &unpair_device_invalid_param_test_1,
6711                                 NULL, test_command_generic);
6712         test_bredrle("Unpair Device - Invalid Parameters 2",
6713                                 &unpair_device_invalid_param_test_2,
6714                                 NULL, test_command_generic);
6715
6716         test_bredrle("Disconnect - Invalid Parameters 1",
6717                                 &disconnect_invalid_param_test_1,
6718                                 NULL, test_command_generic);
6719
6720         test_bredrle("Block Device - Invalid Parameters 1",
6721                                 &block_device_invalid_param_test_1,
6722                                 NULL, test_command_generic);
6723
6724         test_bredrle("Unblock Device - Invalid Parameters 1",
6725                                 &unblock_device_invalid_param_test_1,
6726                                 NULL, test_command_generic);
6727
6728         test_le("Set Static Address - Success 1",
6729                                 &set_static_addr_success_test,
6730                                 NULL, test_command_generic);
6731         test_bredrle("Set Static Address - Success 2",
6732                                 &set_static_addr_success_test_2,
6733                                 NULL, test_command_generic);
6734         test_bredrle("Set Static Address - Failure 1",
6735                                 &set_static_addr_failure_test,
6736                                 NULL, test_command_generic);
6737         test_bredr("Set Static Address - Failure 2",
6738                                 &set_static_addr_failure_test_2,
6739                                 NULL, test_command_generic);
6740
6741         test_bredrle("Set Scan Parameters - Success",
6742                                 &set_scan_params_success_test,
6743                                 NULL, test_command_generic);
6744
6745         test_bredrle("Load IRKs - Success 1",
6746                                 &load_irks_success1_test,
6747                                 NULL, test_command_generic);
6748         test_bredrle("Load IRKs - Success 2",
6749                                 &load_irks_success2_test,
6750                                 NULL, test_command_generic);
6751         test_bredrle("Load IRKs - Invalid Parameters 1",
6752                                 &load_irks_nval_param1_test,
6753                                 NULL, test_command_generic);
6754         test_bredrle("Load IRKs - Invalid Parameters 2",
6755                                 &load_irks_nval_param2_test,
6756                                 NULL, test_command_generic);
6757         test_bredrle("Load IRKs - Invalid Parameters 3",
6758                                 &load_irks_nval_param3_test,
6759                                 NULL, test_command_generic);
6760         test_bredr("Load IRKs - Not Supported",
6761                                 &load_irks_not_supported_test,
6762                                 NULL, test_command_generic);
6763
6764         test_bredrle("Set Privacy - Success",
6765                                 &set_privacy_success_test,
6766                                 NULL, test_command_generic);
6767         test_bredrle("Set Privacy - Rejected",
6768                                 &set_privacy_powered_test,
6769                                 NULL, test_command_generic);
6770         test_bredrle("Set Privacy - Invalid Parameters",
6771                                 &set_privacy_nval_param_test,
6772                                 NULL, test_command_generic);
6773
6774         test_bredrle("Get Conn Info - Success",
6775                                 &get_conn_info_succes1_test, NULL,
6776                                 test_command_generic_connect);
6777         test_bredrle("Get Conn Info - Not Connected",
6778                                 &get_conn_info_ncon_test, NULL,
6779                                 test_command_generic);
6780         test_bredrle("Get Conn Info - Power off",
6781                                 &get_conn_info_power_off_test, NULL,
6782                                 test_command_generic_connect);
6783
6784         test_bredrle("Load Connection Parameters - Invalid Params 1",
6785                                 &load_conn_params_fail_1,
6786                                 NULL, test_command_generic);
6787
6788         test_bredrle("Add Device - Invalid Params 1",
6789                                 &add_device_fail_1,
6790                                 NULL, test_command_generic);
6791         test_bredrle("Add Device - Invalid Params 2",
6792                                 &add_device_fail_2,
6793                                 NULL, test_command_generic);
6794         test_bredrle("Add Device - Invalid Params 3",
6795                                 &add_device_fail_3,
6796                                 NULL, test_command_generic);
6797         test_bredrle("Add Device - Invalid Params 4",
6798                                 &add_device_fail_4,
6799                                 NULL, test_command_generic);
6800         test_bredrle("Add Device - Success 1",
6801                                 &add_device_success_1,
6802                                 NULL, test_command_generic);
6803         test_bredrle("Add Device - Success 2",
6804                                 &add_device_success_2,
6805                                 NULL, test_command_generic);
6806         test_bredrle("Add Device - Success 3",
6807                                 &add_device_success_3,
6808                                 NULL, test_command_generic);
6809         test_bredrle("Add Device - Success 4",
6810                                 &add_device_success_4,
6811                                 NULL, test_command_generic);
6812         test_bredrle("Add Device - Success 5",
6813                                 &add_device_success_5,
6814                                 NULL, test_command_generic);
6815
6816         test_bredrle("Remove Device - Invalid Params 1",
6817                                 &remove_device_fail_1,
6818                                 NULL, test_command_generic);
6819         test_bredrle("Remove Device - Invalid Params 2",
6820                                 &remove_device_fail_2,
6821                                 NULL, test_command_generic);
6822         test_bredrle("Remove Device - Invalid Params 3",
6823                                 &remove_device_fail_3,
6824                                 NULL, test_command_generic);
6825         test_bredrle("Remove Device - Success 1",
6826                                 &remove_device_success_1,
6827                                 setup_add_device, test_command_generic);
6828         test_bredrle("Remove Device - Success 2",
6829                                 &remove_device_success_2,
6830                                 setup_add_device, test_command_generic);
6831         test_bredrle("Remove Device - Success 3",
6832                                 &remove_device_success_3,
6833                                 setup_add_device, test_remove_device);
6834         test_le("Remove Device - Success 4",
6835                                 &remove_device_success_4,
6836                                 setup_add_device, test_remove_device);
6837         test_le("Remove Device - Success 5",
6838                                 &remove_device_success_5,
6839                                 setup_add_device, test_remove_device);
6840
6841         test_bredrle("Read Advertising Features - Invalid parameters",
6842                                 &read_adv_features_invalid_param_test,
6843                                 NULL, test_command_generic);
6844         test_bredrle("Read Advertising Features - Invalid index",
6845                                 &read_adv_features_invalid_index_test,
6846                                 NULL, test_command_generic);
6847         test_bredrle("Read Advertising Features - Success 1 (No instance)",
6848                                 &read_adv_features_success_1,
6849                                 NULL, test_command_generic);
6850         test_bredrle("Read Advertising Features - Success 2 (One instance)",
6851                                 &read_adv_features_success_2,
6852                                 setup_add_advertising,
6853                                 test_command_generic);
6854
6855         test_bredrle("Add Advertising - Failure: LE off",
6856                                         &add_advertising_fail_1,
6857                                         NULL, test_command_generic);
6858         test_bredrle("Add Advertising - Invalid Params 1 (AD too long)",
6859                                         &add_advertising_fail_2,
6860                                         NULL, test_command_generic);
6861         test_bredrle("Add Advertising - Invalid Params 2 (Malformed len)",
6862                                         &add_advertising_fail_3,
6863                                         NULL, test_command_generic);
6864         test_bredrle("Add Advertising - Invalid Params 3 (Malformed len)",
6865                                         &add_advertising_fail_4,
6866                                         NULL, test_command_generic);
6867         test_bredrle("Add Advertising - Invalid Params 4 (Malformed len)",
6868                                         &add_advertising_fail_5,
6869                                         NULL, test_command_generic);
6870         test_le("Add Advertising - Invalid Params 5 (AD too long)",
6871                                         &add_advertising_fail_6,
6872                                         NULL, test_command_generic);
6873         test_bredrle("Add Advertising - Invalid Params 6 (ScRsp too long)",
6874                                         &add_advertising_fail_7,
6875                                         NULL, test_command_generic);
6876         test_bredrle("Add Advertising - Invalid Params 7 (Malformed len)",
6877                                         &add_advertising_fail_8,
6878                                         NULL, test_command_generic);
6879         test_bredrle("Add Advertising - Invalid Params 8 (Malformed len)",
6880                                         &add_advertising_fail_9,
6881                                         NULL, test_command_generic);
6882         test_bredrle("Add Advertising - Invalid Params 9 (Malformed len)",
6883                                         &add_advertising_fail_10,
6884                                         NULL, test_command_generic);
6885         test_le("Add Advertising - Invalid Params 10 (ScRsp too long)",
6886                                         &add_advertising_fail_11,
6887                                         NULL, test_command_generic);
6888         test_bredrle("Add Advertising - Rejected (Timeout, !Powered)",
6889                                         &add_advertising_fail_12,
6890                                         NULL, test_command_generic);
6891         test_bredrle("Add Advertising - Success 1 (Powered, Add Adv Inst)",
6892                                         &add_advertising_success_1,
6893                                         NULL, test_command_generic);
6894         test_bredrle("Add Advertising - Success 2 (!Powered, Add Adv Inst)",
6895                                         &add_advertising_success_pwron_data,
6896                                         setup_add_advertising_not_powered,
6897                                         test_command_generic);
6898         test_bredrle("Add Advertising - Success 3 (!Powered, Adv Enable)",
6899                                         &add_advertising_success_pwron_enabled,
6900                                         setup_add_advertising_not_powered,
6901                                         test_command_generic);
6902         test_bredrle("Add Advertising - Success 4 (Set Adv on override)",
6903                                         &add_advertising_success_4,
6904                                         setup_add_advertising,
6905                                         test_command_generic);
6906         test_bredrle("Add Advertising - Success 5 (Set Adv off override)",
6907                                         &add_advertising_success_5,
6908                                         setup_set_and_add_advertising,
6909                                         test_command_generic);
6910         test_bredrle("Add Advertising - Success 6 (Scan Rsp Dta, Adv ok)",
6911                                         &add_advertising_success_6,
6912                                         NULL, test_command_generic);
6913         test_bredrle("Add Advertising - Success 7 (Scan Rsp Dta, Scan ok) ",
6914                                         &add_advertising_success_7,
6915                                         NULL, test_command_generic);
6916         test_bredrle("Add Advertising - Success 8 (Connectable Flag)",
6917                                         &add_advertising_success_8,
6918                                         NULL, test_command_generic);
6919         test_bredrle("Add Advertising - Success 9 (General Discov Flag)",
6920                                         &add_advertising_success_9,
6921                                         NULL, test_command_generic);
6922         test_bredrle("Add Advertising - Success 10 (Limited Discov Flag)",
6923                                         &add_advertising_success_10,
6924                                         NULL, test_command_generic);
6925         test_bredrle("Add Advertising - Success 11 (Managed Flags)",
6926                                         &add_advertising_success_11,
6927                                         NULL, test_command_generic);
6928         test_bredrle("Add Advertising - Success 12 (TX Power Flag)",
6929                                         &add_advertising_success_12,
6930                                         NULL, test_command_generic);
6931         test_bredrle("Add Advertising - Success 13 (ADV_SCAN_IND)",
6932                                         &add_advertising_success_13,
6933                                         NULL, test_command_generic);
6934         test_bredrle("Add Advertising - Success 14 (ADV_NONCONN_IND)",
6935                                         &add_advertising_success_14,
6936                                         NULL, test_command_generic);
6937         test_bredrle("Add Advertising - Success 15 (ADV_IND)",
6938                                         &add_advertising_success_15,
6939                                         NULL, test_command_generic);
6940         test_bredrle("Add Advertising - Success 16 (Connectable -> on)",
6941                                         &add_advertising_success_16,
6942                                         setup_add_advertising,
6943                                         test_command_generic);
6944         test_bredrle("Add Advertising - Success 17 (Connectable -> off)",
6945                                         &add_advertising_success_17,
6946                                         setup_add_advertising_connectable,
6947                                         test_command_generic);
6948         /* Adv instances with a timeout do NOT survive a power cycle. */
6949         test_bredrle("Add Advertising - Success 18 (Power -> off, Remove)",
6950                                         &add_advertising_power_off,
6951                                         setup_add_advertising_timeout,
6952                                         test_command_generic);
6953         /* Adv instances without timeout survive a power cycle. */
6954         test_bredrle("Add Advertising - Success 19 (Power -> off, Keep)",
6955                                         &add_advertising_success_pwron_data,
6956                                         setup_add_advertising_power_cycle,
6957                                         test_command_generic);
6958         /* Changing an advertising instance while it is still being
6959          * advertised will immediately update the advertised data if
6960          * there is no other instance to switch to.
6961          */
6962         test_bredrle("Add Advertising - Success 20 (Add Adv override)",
6963                                         &add_advertising_success_18,
6964                                         setup_add_advertising,
6965                                         test_command_generic);
6966         /* An instance should be removed when its timeout has been reached.
6967          * Advertising will also be disabled if this was the last instance.
6968          */
6969         test_bredrle_full("Add Advertising - Success 21 (Timeout expires)",
6970                                         &add_advertising_timeout_expired,
6971                                         setup_add_advertising_timeout,
6972                                         test_command_generic, 3);
6973         /* LE off will clear (remove) all instances. */
6974         test_bredrle("Add Advertising - Success 22 (LE -> off, Remove)",
6975                                         &add_advertising_le_off,
6976                                         setup_add_advertising,
6977                                         test_command_generic);
6978
6979
6980         test_bredrle("Remove Advertising - Invalid Params 1",
6981                                         &remove_advertising_fail_1,
6982                                         NULL, test_command_generic);
6983         test_bredrle("Remove Advertising - Success 1",
6984                                                 &remove_advertising_success_1,
6985                                                 setup_add_advertising,
6986                                                 test_command_generic);
6987         test_bredrle("Remove Advertising - Success 2",
6988                                                 &remove_advertising_success_2,
6989                                                 setup_add_advertising,
6990                                                 test_command_generic);
6991
6992         /* When advertising two instances, the instances should be
6993          * advertised in a round-robin fashion.
6994          */
6995         test_bredrle("Multi Advertising - Success 1 (Instance Switch)",
6996                                         &multi_advertising_switch,
6997                                         setup_multi_adv,
6998                                         test_command_generic);
6999         /* Adding a new instance when one is already being advertised
7000          * will switch to the new instance after the first has reached
7001          * its duration. A long timeout has been set to
7002          */
7003         test_bredrle_full("Multi Advertising - Success 2 (Add Second Inst)",
7004                                         &multi_advertising_add_second,
7005                                         setup_add_advertising_duration,
7006                                         test_command_generic, 3);
7007
7008         test_bredrle("Read Local OOB Data - Not powered",
7009                                 &read_local_oob_not_powered_test,
7010                                 NULL, test_command_generic);
7011         test_bredrle("Read Local OOB Data - Invalid parameters",
7012                                 &read_local_oob_invalid_param_test,
7013                                 NULL, test_command_generic);
7014         test_bredrle("Read Local OOB Data - Invalid index",
7015                                 &read_local_oob_invalid_index_test,
7016                                 NULL, test_command_generic);
7017         test_bredr20("Read Local OOB Data - Legacy pairing",
7018                                 &read_local_oob_legacy_pairing_test,
7019                                 NULL, test_command_generic);
7020         test_bredrle("Read Local OOB Data - Success SSP",
7021                                 &read_local_oob_success_ssp_test,
7022                                 NULL, test_command_generic);
7023         test_bredrle("Read Local OOB Data - Success SC",
7024                                 &read_local_oob_success_sc_test,
7025                                 NULL, test_command_generic);
7026
7027         test_bredrle("Device Found - Advertising data - Zero padded",
7028                                 &device_found_gtag,
7029                                 NULL, test_device_found);
7030         test_bredrle("Device Found - Advertising data - Invalid field",
7031                                 &device_found_invalid_field,
7032                                 NULL, test_device_found);
7033
7034         return tester_run();
7035 }