source4/lib/registry/tests/registry.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    local testing of registry library - registry backend
   5
   6    Copyright (C) Jelmer Vernooij 2005-2007
   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 3 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., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "lib/registry/registry.h"
  25 #include "torture/torture.h"
  26 #include "librpc/gen_ndr/winreg.h"
  27 #include "libcli/security/security.h"
  28 #include "system/filesys.h"
  29 #include "lib/registry/tests/proto.h"
  30
  31 /**
  32  * Test obtaining a predefined key.
  33  */
  34 static bool test_get_predefined(struct torture_context *tctx, void *_data)
  35 {
  36         struct registry_context *rctx = (struct registry_context *)_data;
  37         struct registry_key *root;
  38         WERROR error;
  39
  40         error = reg_get_predefined_key(rctx, HKEY_CLASSES_ROOT, &root);
  41         torture_assert_werr_ok(tctx, error,
  42                                "getting predefined key failed");
  43         return true;
  44 }
  45
  46 /**
  47  * Test obtaining a predefined key.
  48  */
  49 static bool test_get_predefined_unknown(struct torture_context *tctx,
  50                 void *_data)
  51 {
  52         struct registry_context *rctx = _data;
  53         struct registry_key *root;
  54         WERROR error;
  55
  56         error = reg_get_predefined_key(rctx, 1337, &root);
  57         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
  58                                   "getting predefined key failed");
  59         return true;
  60 }
  61
  62 static bool test_predef_key_by_name(struct torture_context *tctx, void *_data)
  63 {
  64         struct registry_context *rctx = (struct registry_context *)_data;
  65         struct registry_key *root;
  66         WERROR error;
  67
  68         error = reg_get_predefined_key_by_name(rctx, "HKEY_CLASSES_ROOT",
  69                                                &root);
  70         torture_assert_werr_ok(tctx, error,
  71                                "getting predefined key failed");
  72
  73         error = reg_get_predefined_key_by_name(rctx, "HKEY_classes_ROOT",
  74                                                &root);
  75         torture_assert_werr_ok(tctx, error,
  76                                "getting predefined key case insensitively failed");
  77
  78         return true;
  79 }
  80
  81 static bool test_predef_key_by_name_invalid(struct torture_context *tctx,
  82                 void *_data)
  83 {
  84         struct registry_context *rctx = (struct registry_context *)_data;
  85         struct registry_key *root;
  86         WERROR error;
  87
  88         error = reg_get_predefined_key_by_name(rctx, "BLA", &root);
  89         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
  90                                   "getting predefined key failed");
  91         return true;
  92 }
  93
  94 /**
  95  * Test creating a new subkey
  96  */
  97 static bool test_create_subkey(struct torture_context *tctx, void *_data)
  98 {
  99         struct registry_context *rctx = (struct registry_context *)_data;
 100         struct registry_key *root, *newkey;
 101         WERROR error;
 102
 103         error = reg_get_predefined_key(rctx, HKEY_CLASSES_ROOT, &root);
 104         torture_assert_werr_ok(tctx, error,
 105                                "getting predefined key failed");
 106
 107         error = reg_key_add_name(rctx, root, "Bad Bentheim", NULL, NULL,
 108                                  &newkey);
 109         torture_assert_werr_ok(tctx, error, "Creating key return code");
 110         torture_assert(tctx, newkey != NULL, "Creating new key");
 111
 112         return true;
 113 }
 114
 115 /**
 116  * Test creating a new nested subkey
 117  */
 118 static bool test_create_nested_subkey(struct torture_context *tctx, void *_data)
 119 {
 120         struct registry_context *rctx = (struct registry_context *)_data;
 121         struct registry_key *root, *newkey;
 122         WERROR error;
 123
 124         error = reg_get_predefined_key(rctx, HKEY_CLASSES_ROOT, &root);
 125         torture_assert_werr_ok(tctx, error,
 126                                "getting predefined key failed");
 127
 128         error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
 129                                  &newkey);
 130         torture_assert_werr_ok(tctx, error, "Creating key return code");
 131         torture_assert(tctx, newkey != NULL, "Creating new key");
 132
 133         return true;
 134 }
 135
 136 /**
 137  * Test creating a new subkey
 138  */
 139 static bool test_key_add_abs_top(struct torture_context *tctx, void *_data)
 140 {
 141         struct registry_context *rctx = (struct registry_context *)_data;
 142         struct registry_key *root;
 143         WERROR error;
 144
 145         error = reg_key_add_abs(tctx, rctx, "HKEY_CLASSES_ROOT", 0, NULL,
 146                                 &root);
 147         torture_assert_werr_equal(tctx, error, WERR_ALREADY_EXISTS,
 148                                   "create top level");
 149
 150         return true;
 151 }
 152
 153 /**
 154  * Test creating a new subkey
 155  */
 156 static bool test_key_add_abs(struct torture_context *tctx, void *_data)
 157 {
 158         WERROR error;
 159         struct registry_context *rctx = (struct registry_context *)_data;
 160         struct registry_key *root, *result1, *result2;
 161
 162         error = reg_key_add_abs(tctx, rctx,  "HKEY_CLASSES_ROOT\\bloe", 0, NULL,
 163                                 &result1);
 164         torture_assert_werr_ok(tctx, error, "create lowest");
 165
 166         error = reg_key_add_abs(tctx, rctx,  "HKEY_CLASSES_ROOT\\bloe\\bla", 0,
 167                                 NULL, &result1);
 168         torture_assert_werr_ok(tctx, error, "create nested");
 169
 170         error = reg_get_predefined_key(rctx, HKEY_CLASSES_ROOT, &root);
 171         torture_assert_werr_ok(tctx, error,
 172                                "getting predefined key failed");
 173
 174         error = reg_open_key(tctx, root, "bloe", &result2);
 175         torture_assert_werr_ok(tctx, error, "opening key");
 176
 177         error = reg_open_key(tctx, root, "bloe\\bla", &result2);
 178         torture_assert_werr_ok(tctx, error, "opening key");
 179
 180         return true;
 181 }
 182
 183
 184 static bool test_del_key(struct torture_context *tctx, void *_data)
 185 {
 186         struct registry_context *rctx = (struct registry_context *)_data;
 187         struct registry_key *root, *newkey;
 188         WERROR error;
 189
 190         error = reg_get_predefined_key(rctx, HKEY_CLASSES_ROOT, &root);
 191         torture_assert_werr_ok(tctx, error,
 192                                "getting predefined key failed");
 193
 194         error = reg_key_add_name(rctx, root, "Polen", NULL, NULL, &newkey);
 195
 196         torture_assert_werr_ok(tctx, error, "Creating key return code");
 197         torture_assert(tctx, newkey != NULL, "Creating new key");
 198
 199         error = reg_key_del(tctx, root, "Polen");
 200         torture_assert_werr_ok(tctx, error, "Delete key");
 201
 202         error = reg_key_del(tctx, root, "Polen");
 203         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
 204                                   "Delete missing key");
 205
 206         return true;
 207 }
 208
 209 /**
 210  * Convenience function for opening the HKEY_CLASSES_ROOT hive and
 211  * creating a single key for testing purposes.
 212  */
 213 static bool create_test_key(struct torture_context *tctx,
 214                             struct registry_context *rctx,
 215                             const char *name,
 216                             struct registry_key **root,
 217                             struct registry_key **subkey)
 218 {
 219         WERROR error;
 220
 221         error = reg_get_predefined_key(rctx, HKEY_CLASSES_ROOT, root);
 222         torture_assert_werr_ok(tctx, error,
 223                                "getting predefined key failed");
 224
 225         error = reg_key_add_name(rctx, *root, name, NULL, NULL, subkey);
 226         torture_assert_werr_ok(tctx, error, "Creating key return code");
 227
 228         return true;
 229 }
 230
 231
 232 static bool test_flush_key(struct torture_context *tctx, void *_data)
 233 {
 234         struct registry_context *rctx = (struct registry_context *)_data;
 235         struct registry_key *root, *subkey;
 236         WERROR error;
 237
 238         if (!create_test_key(tctx, rctx, "Bremen", &root, &subkey))
 239                 return false;
 240
 241         error = reg_key_flush(subkey);
 242         torture_assert_werr_ok(tctx, error, "flush key");
 243
 244         torture_assert_werr_equal(tctx, reg_key_flush(NULL),
 245                                   WERR_INVALID_PARAM, "flush key");
 246
 247         return true;
 248 }
 249
 250 static bool test_query_key(struct torture_context *tctx, void *_data)
 251 {
 252         struct registry_context *rctx = (struct registry_context *)_data;
 253         struct registry_key *root, *subkey;
 254         WERROR error;
 255         NTTIME last_changed_time;
 256         uint32_t num_subkeys, num_values;
 257         const char *classname;
 258         const char *data = "temp";
 259
 260         if (!create_test_key(tctx, rctx, "Muenchen", &root, &subkey))
 261                 return false;
 262
 263         error = reg_key_get_info(tctx, subkey, &classname,
 264                                  &num_subkeys, &num_values,
 265                                  &last_changed_time, NULL, NULL, NULL);
 266
 267         torture_assert_werr_ok(tctx, error, "get info key");
 268         torture_assert(tctx, classname == NULL, "classname");
 269         torture_assert_int_equal(tctx, num_subkeys, 0, "num subkeys");
 270         torture_assert_int_equal(tctx, num_values, 0, "num values");
 271
 272         error = reg_val_set(subkey, "", REG_SZ,
 273                             data_blob_talloc(tctx, data, sizeof(data)));
 274         torture_assert_werr_ok(tctx, error, "set default value");
 275
 276         error = reg_key_get_info(tctx, subkey, &classname,
 277                                  &num_subkeys, &num_values,
 278                                  &last_changed_time, NULL, NULL, NULL);
 279
 280         torture_assert_werr_ok(tctx, error, "get info key");
 281         torture_assert(tctx, classname == NULL, "classname");
 282         torture_assert_int_equal(tctx, num_subkeys, 0, "num subkeys");
 283         torture_assert_int_equal(tctx, num_values, 1, "num values");
 284
 285         return true;
 286 }
 287
 288 static bool test_query_key_nums(struct torture_context *tctx, void *_data)
 289 {
 290         struct registry_context *rctx = (struct registry_context *)_data;
 291         struct registry_key *root, *subkey1, *subkey2;
 292         WERROR error;
 293         uint32_t num_subkeys, num_values;
 294         char data[4];
 295         SIVAL(data, 0, 42);
 296
 297         if (!create_test_key(tctx, rctx, "Berlin", &root, &subkey1))
 298                 return false;
 299
 300         error = reg_key_add_name(rctx, subkey1, "Bentheim", NULL, NULL,
 301                                  &subkey2);
 302         torture_assert_werr_ok(tctx, error, "Creating key return code");
 303
 304         error = reg_val_set(subkey1, "Answer", REG_DWORD,
 305                             data_blob_talloc(tctx, &data, sizeof(data)));
 306         torture_assert_werr_ok(tctx, error, "set value");
 307
 308         error = reg_key_get_info(tctx, subkey1, NULL, &num_subkeys,
 309                                  &num_values, NULL, NULL, NULL, NULL);
 310
 311         torture_assert_werr_ok(tctx, error, "get info key");
 312         torture_assert_int_equal(tctx, num_subkeys, 1, "num subkeys");
 313         torture_assert_int_equal(tctx, num_values, 1, "num values");
 314
 315         return true;
 316 }
 317
 318 /**
 319  * Test that the subkeys of a key can be enumerated, that
 320  * the returned parameters for get_subkey_by_index are optional and
 321  * that enumerating the parents of a non-top-level node works.
 322  */
 323 static bool test_list_subkeys(struct torture_context *tctx, void *_data)
 324 {
 325         struct registry_context *rctx = (struct registry_context *)_data;
 326         struct registry_key *subkey = NULL, *root;
 327         WERROR error;
 328         NTTIME last_mod_time;
 329         const char *classname, *name;
 330
 331         if (!create_test_key(tctx, rctx, "Goettingen", &root, &subkey))
 332                 return false;
 333
 334         error = reg_key_get_subkey_by_index(tctx, root, 0, &name, &classname,
 335                                             &last_mod_time);
 336
 337         torture_assert_werr_ok(tctx, error, "Enum keys return code");
 338         torture_assert_str_equal(tctx, name, "Goettingen", "Enum keys data");
 339
 340
 341         error = reg_key_get_subkey_by_index(tctx, root, 0, NULL, NULL, NULL);
 342
 343         torture_assert_werr_ok(tctx, error,
 344                                "Enum keys with NULL arguments return code");
 345
 346         error = reg_key_get_subkey_by_index(tctx, root, 1, NULL, NULL, NULL);
 347
 348         torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
 349                                   "Invalid error for no more items");
 350
 351         error = reg_key_get_subkey_by_index(tctx, subkey, 0, NULL, NULL, NULL);
 352
 353         torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
 354                                   "Invalid error for no more items");
 355
 356         return true;
 357 }
 358
 359 /**
 360  * Test setting a value
 361  */
 362 static bool test_set_value(struct torture_context *tctx, void *_data)
 363 {
 364         struct registry_context *rctx = (struct registry_context *)_data;
 365         struct registry_key *subkey = NULL, *root;
 366         WERROR error;
 367         char data[4];
 368
 369         SIVAL(data, 0, 42);
 370
 371         if (!create_test_key(tctx, rctx, "Dusseldorf", &root, &subkey))
 372                 return false;
 373
 374         error = reg_val_set(subkey, "Answer", REG_DWORD,
 375                             data_blob_talloc(tctx, data, sizeof(data)));
 376         torture_assert_werr_ok (tctx, error, "setting value");
 377
 378         return true;
 379 }
 380
 381 /**
 382  * Test getting/setting security descriptors
 383  */
 384 static bool test_security(struct torture_context *tctx, void *_data)
 385 {
 386         struct registry_context *rctx = (struct registry_context *)_data;
 387         struct registry_key *subkey = NULL, *root;
 388         WERROR error;
 389         struct security_descriptor *osd, *nsd;
 390
 391         if (!create_test_key(tctx, rctx, "Düsseldorf", &root, &subkey))
 392                 return false;
 393
 394         osd = security_descriptor_dacl_create(tctx,
 395                                          0,
 396                                          NULL, NULL,
 397                                          SID_NT_AUTHENTICATED_USERS,
 398                                          SEC_ACE_TYPE_ACCESS_ALLOWED,
 399                                          SEC_GENERIC_ALL,
 400                                          SEC_ACE_FLAG_OBJECT_INHERIT,
 401                                          NULL);
 402
 403         error = reg_set_sec_desc(subkey, osd);
 404         torture_assert_werr_ok(tctx, error, "setting security descriptor");
 405
 406         error = reg_get_sec_desc(tctx, subkey, &nsd);
 407         torture_assert_werr_ok (tctx, error, "getting security descriptor");
 408
 409         torture_assert(tctx, security_descriptor_equal(osd, nsd),
 410                        "security descriptor changed!");
 411
 412         return true;
 413 }
 414
 415 /**
 416  * Test getting a value
 417  */
 418 static bool test_get_value(struct torture_context *tctx, void *_data)
 419 {
 420         struct registry_context *rctx = (struct registry_context *)_data;
 421         struct registry_key *subkey = NULL, *root;
 422         WERROR error;
 423         DATA_BLOB data;
 424         char value[4];
 425         uint32_t type;
 426         const char *data_val = "temp";
 427
 428         SIVAL(value, 0, 42);
 429
 430         if (!create_test_key(tctx, rctx, "Duisburg", &root, &subkey))
 431                 return false;
 432
 433         error = reg_key_get_value_by_name(tctx, subkey, __FUNCTION__, &type,
 434                                           &data);
 435         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
 436                                   "getting missing value");
 437
 438         error = reg_val_set(subkey, __FUNCTION__, REG_DWORD,
 439                             data_blob_talloc(tctx, value, sizeof(value)));
 440         torture_assert_werr_ok(tctx, error, "setting value");
 441
 442         error = reg_key_get_value_by_name(tctx, subkey, __FUNCTION__, &type,
 443                                           &data);
 444         torture_assert_werr_ok(tctx, error, "getting value");
 445
 446         torture_assert_int_equal(tctx, sizeof(value), data.length, "value length ok");
 447         torture_assert_mem_equal(tctx, data.data, value, sizeof(value),
 448                                  "value content ok");
 449         torture_assert_int_equal(tctx, REG_DWORD, type, "value type");
 450
 451         error = reg_val_set(subkey, "", REG_SZ,
 452                             data_blob_talloc(tctx, data_val, sizeof(data_val)));
 453         torture_assert_werr_ok(tctx, error, "set default value");
 454
 455         error = reg_key_get_value_by_name(tctx, subkey, "", &type,
 456                                           &data);
 457         torture_assert_werr_ok(tctx, error, "getting default value");
 458         torture_assert_int_equal(tctx, REG_SZ, type, "value type ok");
 459         torture_assert_int_equal(tctx, sizeof(data_val), data.length, "value length ok");
 460         torture_assert_str_equal(tctx, data_val, (char *)data.data, "value ok");
 461
 462         return true;
 463 }
 464
 465 /**
 466  * Test unsetting a value
 467  */
 468 static bool test_del_value(struct torture_context *tctx, void *_data)
 469 {
 470         struct registry_context *rctx =(struct registry_context *)_data;
 471         struct registry_key *subkey = NULL, *root;
 472         WERROR error;
 473         DATA_BLOB data;
 474         uint32_t type;
 475         char value[4];
 476         const char *data_val = "temp";
 477
 478         SIVAL(value, 0, 42);
 479
 480         if (!create_test_key(tctx, rctx, "Warschau", &root, &subkey))
 481                 return false;
 482
 483         error = reg_key_get_value_by_name(tctx, subkey, __FUNCTION__, &type,
 484                                           &data);
 485         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
 486                                   "getting missing value");
 487
 488         error = reg_val_set(subkey, __FUNCTION__, REG_DWORD,
 489                             data_blob_talloc(tctx, value, sizeof(value)));
 490         torture_assert_werr_ok (tctx, error, "setting value");
 491
 492         error = reg_del_value(tctx, subkey, __FUNCTION__);
 493         torture_assert_werr_ok (tctx, error, "unsetting value");
 494
 495         error = reg_key_get_value_by_name(tctx, subkey, __FUNCTION__,
 496                                           &type, &data);
 497         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
 498                                   "getting missing value");
 499
 500         error = reg_del_value(tctx, subkey, "");
 501         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
 502                                   "unsetting missing default value");
 503
 504         error = reg_val_set(subkey, "", REG_SZ,
 505                             data_blob_talloc(tctx, data_val, sizeof(data_val)));
 506         torture_assert_werr_ok(tctx, error, "set default value");
 507
 508         error = reg_del_value(tctx, subkey, "");
 509         torture_assert_werr_ok (tctx, error, "unsetting default value");
 510
 511         return true;
 512 }
 513
 514 /**
 515  * Test listing values
 516  */
 517 static bool test_list_values(struct torture_context *tctx, void *_data)
 518 {
 519         struct registry_context *rctx = (struct registry_context *)_data;
 520         struct registry_key *subkey = NULL, *root;
 521         WERROR error;
 522         DATA_BLOB data;
 523         uint32_t type;
 524         const char *name;
 525         char value[4];
 526         const char *data_val = "temp";
 527
 528         SIVAL(value, 0, 42);
 529
 530         if (!create_test_key(tctx, rctx, "Bonn", &root, &subkey))
 531                 return false;
 532
 533         error = reg_val_set(subkey, "bar", REG_DWORD,
 534                             data_blob_talloc(tctx, value, sizeof(value)));
 535         torture_assert_werr_ok (tctx, error, "setting value");
 536
 537         error = reg_key_get_value_by_index(tctx, subkey, 0, &name,
 538                                            &type, &data);
 539         torture_assert_werr_ok(tctx, error, "getting value");
 540
 541         torture_assert_str_equal(tctx, name, "bar", "value name");
 542         torture_assert_int_equal(tctx, sizeof(value), data.length, "value length");
 543         torture_assert_mem_equal(tctx, data.data, value, sizeof(value),
 544                        "value content");
 545         torture_assert_int_equal(tctx, REG_DWORD, type, "value type");
 546
 547         error = reg_key_get_value_by_index(tctx, subkey, 1, &name,
 548                                            &type, &data);
 549         torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
 550                                   "getting missing value");
 551
 552         error = reg_val_set(subkey, "", REG_SZ,
 553                             data_blob_talloc(tctx, data_val, sizeof(data_val)));
 554         torture_assert_werr_ok(tctx, error, "set default value");
 555
 556         error = reg_key_get_value_by_index(tctx, subkey, 0, &name,
 557                                            &type, &data);
 558         torture_assert_werr_ok(tctx, error, "getting default value");
 559         torture_assert_int_equal(tctx, REG_SZ, type, "value type ok");
 560         torture_assert_int_equal(tctx, sizeof(data_val), data.length, "value length ok");
 561         torture_assert_str_equal(tctx, data_val, (char *)data.data, "value ok");
 562
 563         return true;
 564 }
 565
 566 static bool setup_local_registry(struct torture_context *tctx, void **data)
 567 {
 568         struct registry_context *rctx;
 569         WERROR error;
 570         char *tempdir;
 571         NTSTATUS status;
 572         struct hive_key *hive_key;
 573         const char *filename;
 574
 575         error = reg_open_local(tctx, &rctx);
 576         torture_assert_werr_ok(tctx, error, "Opening local registry failed");
 577
 578         status = torture_temp_dir(tctx, "registry-local", &tempdir);
 579         torture_assert_ntstatus_ok(tctx, status, "Creating temp dir failed");
 580
 581         filename = talloc_asprintf(tctx, "%s/classes_root.ldb", tempdir);
 582         error = reg_open_ldb_file(tctx, filename, NULL, NULL, tctx->ev, tctx->lp_ctx, &hive_key);
 583         torture_assert_werr_ok(tctx, error, "Opening classes_root file failed");
 584
 585         error = reg_mount_hive(rctx, hive_key, HKEY_CLASSES_ROOT, NULL);
 586         torture_assert_werr_ok(tctx, error, "Mounting hive failed");
 587
 588         *data = rctx;
 589
 590         return true;
 591 }
 592
 593 static void tcase_add_tests(struct torture_tcase *tcase)
 594 {
 595         torture_tcase_add_simple_test(tcase, "list_subkeys",
 596                                         test_list_subkeys);
 597         torture_tcase_add_simple_test(tcase, "get_predefined_key",
 598                                         test_get_predefined);
 599         torture_tcase_add_simple_test(tcase, "get_predefined_key",
 600                                         test_get_predefined_unknown);
 601         torture_tcase_add_simple_test(tcase, "create_key",
 602                                         test_create_subkey);
 603         torture_tcase_add_simple_test(tcase, "create_key",
 604                                         test_create_nested_subkey);
 605         torture_tcase_add_simple_test(tcase, "key_add_abs",
 606                                         test_key_add_abs);
 607         torture_tcase_add_simple_test(tcase, "key_add_abs_top",
 608                                         test_key_add_abs_top);
 609         torture_tcase_add_simple_test(tcase, "set_value",
 610                                         test_set_value);
 611         torture_tcase_add_simple_test(tcase, "get_value",
 612                                         test_get_value);
 613         torture_tcase_add_simple_test(tcase, "list_values",
 614                                         test_list_values);
 615         torture_tcase_add_simple_test(tcase, "del_key",
 616                                         test_del_key);
 617         torture_tcase_add_simple_test(tcase, "del_value",
 618                                         test_del_value);
 619         torture_tcase_add_simple_test(tcase, "flush_key",
 620                                         test_flush_key);
 621         torture_tcase_add_simple_test(tcase, "query_key",
 622                                         test_query_key);
 623         torture_tcase_add_simple_test(tcase, "query_key_nums",
 624                                         test_query_key_nums);
 625         torture_tcase_add_simple_test(tcase, "test_predef_key_by_name",
 626                                         test_predef_key_by_name);
 627         torture_tcase_add_simple_test(tcase, "security",
 628                                         test_security);
 629         torture_tcase_add_simple_test(tcase,"test_predef_key_by_name_invalid",
 630                                         test_predef_key_by_name_invalid);
 631 }
 632
 633 struct torture_suite *torture_registry_registry(TALLOC_CTX *mem_ctx)
 634 {
 635         struct torture_tcase *tcase;
 636         struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
 637
 638         tcase = torture_suite_add_tcase(suite, "local");
 639         torture_tcase_set_fixture(tcase, setup_local_registry, NULL);
 640         tcase_add_tests(tcase);
 641
 642         return suite;
 643 }