s4-smbtorture: Make test names lowercase and dot-separated.

[metze/samba/wip.git] / source4 / lib / registry / tests / hive.c

diff --git a/source4/lib/registry/tests/hive.c b/source4/lib/registry/tests/hive.c
index 474704b5170bb3093c270225b51182334a2c7d86..71d3f0a3f8374c6c51bc74259b1f03868395f152 100644 (file)
--- a/source4/lib/registry/tests/hive.c
+++ b/source4/lib/registry/tests/hive.c
@@ -32,7 +32,7 @@ static bool test_del_nonexistant_key(struct torture_context *tctx,
                                     const void *test_data)
 {
        const struct hive_key *root = (const struct hive_key *)test_data;
-       WERROR error = hive_key_del(root, "bla");
+       WERROR error = hive_key_del(tctx, root, "bla");
        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                  "invalid return code");
 
@@ -69,14 +69,14 @@ static bool test_keyinfo_nums(struct torture_context *tctx, void *test_data)
        struct hive_key *root = (struct hive_key *)test_data;
        WERROR error;
        struct hive_key *subkey;
-       uint32_t data = 42;
+       uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+       DATA_BLOB db = { d, 4 };
 
        error = hive_key_add_name(tctx, root, "Nested Keyll", NULL,
                                  NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_key_set_value(root, "Answer", REG_DWORD,
-                              data_blob_talloc(tctx, &data, sizeof(data)));
+       error = hive_key_set_value(root, "Answer", REG_DWORD, db);
        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
        /* This is a new backend. There should be no subkeys and no
@@ -106,7 +106,7 @@ static bool test_add_subkey(struct torture_context *tctx,
                                  NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_key_del(root, "Nested Key");
+       error = hive_key_del(mem_ctx, root, "Nested Key");
        torture_assert_werr_ok(tctx, error, "reg_key_del");
 
        return true;
@@ -120,7 +120,8 @@ static bool test_del_recursive(struct torture_context *tctx,
        struct hive_key *subkey2;
        const struct hive_key *root = (const struct hive_key *)test_data;
        TALLOC_CTX *mem_ctx = tctx;
-       uint32_t data = 42;
+       uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+       DATA_BLOB db = { d, 4 };
 
        /* Create a new key under the root */
        error = hive_key_add_name(mem_ctx, root, "Parent Key", NULL,
@@ -133,12 +134,11 @@ static bool test_del_recursive(struct torture_context *tctx,
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
        /* Create a new value under "Child Key" */
-       error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD,
-                              data_blob_talloc(mem_ctx, &data, sizeof(data)));
+       error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD, db);
        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
        /* Deleting "Parent Key" will also delete "Child Key" and the value. */
-       error = hive_key_del(root, "Parent Key");
+       error = hive_key_del(mem_ctx, root, "Parent Key");
        torture_assert_werr_ok(tctx, error, "hive_key_del");
 
        return true;
@@ -164,10 +164,10 @@ static bool test_del_key(struct torture_context *tctx, const void *test_data)
                                  NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_key_del(root, "Nested Key");
+       error = hive_key_del(mem_ctx, root, "Nested Key");
        torture_assert_werr_ok(tctx, error, "reg_key_del");
 
-       error = hive_key_del(root, "Nested Key");
+       error = hive_key_del(mem_ctx, root, "Nested Key");
        torture_assert_werr_equal(tctx, error, WERR_BADFILE, "reg_key_del");
 
        return true;
@@ -180,14 +180,14 @@ static bool test_set_value(struct torture_context *tctx,
        struct hive_key *subkey;
        const struct hive_key *root = (const struct hive_key *)test_data;
        TALLOC_CTX *mem_ctx = tctx;
-       uint32_t data = 42;
+       uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+       DATA_BLOB db = { d, 4 };
 
        error = hive_key_add_name(mem_ctx, root, "YA Nested Key", NULL,
                                  NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                              data_blob_talloc(mem_ctx, &data, sizeof(data)));
+       error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
        return true;
@@ -199,30 +199,28 @@ static bool test_get_value(struct torture_context *tctx, const void *test_data)
        struct hive_key *subkey;
        const struct hive_key *root = (const struct hive_key *)test_data;
        TALLOC_CTX *mem_ctx = tctx;
-       uint32_t data = 42;
        uint32_t type;
-       DATA_BLOB value;
+       uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+       DATA_BLOB db = { d, 4 }, data;
 
        error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL,
                                  NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+       error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                  "getting missing value");
 
-       error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                              data_blob_talloc(mem_ctx, &data, sizeof(data)));
+       error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
-       error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+       error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
        torture_assert_werr_ok(tctx, error, "getting value");
 
-       torture_assert_int_equal(tctx, value.length, 4, "value length");
+       torture_assert_int_equal(tctx, data.length, 4, "value length");
        torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
 
-       torture_assert_mem_equal(tctx, &data, value.data, sizeof(uint32_t),
-                                "value data");
+       torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
 
        return true;
 }
@@ -233,25 +231,24 @@ static bool test_del_value(struct torture_context *tctx, const void *test_data)
        struct hive_key *subkey;
        const struct hive_key *root = (const struct hive_key *)test_data;
        TALLOC_CTX *mem_ctx = tctx;
-       uint32_t data = 42;
        uint32_t type;
-       DATA_BLOB value;
+       uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+       DATA_BLOB db = { d, 4 };
 
        error = hive_key_add_name(mem_ctx, root, "EEYA Nested Key", NULL,
                                                         NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                              data_blob_talloc(mem_ctx, &data, sizeof(data)));
+       error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
-       error = hive_key_del_value(subkey, "Answer");
+       error = hive_key_del_value(mem_ctx, subkey, "Answer");
        torture_assert_werr_ok(tctx, error, "deleting value");
 
-       error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+       error = hive_get_value(mem_ctx, subkey, "Answer", &type, &db);
        torture_assert_werr_equal(tctx, error, WERR_BADFILE, "getting value");
 
-       error = hive_key_del_value(subkey, "Answer");
+       error = hive_key_del_value(mem_ctx, subkey, "Answer");
        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                  "deleting value");
 
@@ -265,33 +262,31 @@ static bool test_list_values(struct torture_context *tctx,
        struct hive_key *subkey;
        const struct hive_key *root = (const struct hive_key *)test_data;
        TALLOC_CTX *mem_ctx = tctx;
-       uint32_t data = 42;
        uint32_t type;
-       DATA_BLOB value;
+       uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+       DATA_BLOB db = { d, 4 }, data;
        const char *name;
 
        error = hive_key_add_name(mem_ctx, root, "AYAYA Nested Key", NULL,
                                  NULL, &subkey);
        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-       error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                              data_blob_talloc(mem_ctx, &data, sizeof(data)));
+       error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
        error = hive_get_value_by_index(mem_ctx, subkey, 0, &name,
-                                       &type, &value);
+                                       &type, &data);
        torture_assert_werr_ok(tctx, error, "getting value");
 
        torture_assert_str_equal(tctx, name, "Answer", "value name");
 
-       torture_assert_int_equal(tctx, value.length, 4, "value length");
+       torture_assert_int_equal(tctx, data.length, 4, "value length");
        torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
        
+       torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
        
-       torture_assert_int_equal(tctx, data, IVAL(value.data, 0), "value data");
-
        error = hive_get_value_by_index(mem_ctx, subkey, 1, &name,
-                                       &type, &value);
+                                       &type, &data);
        torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
                                  "getting missing value");
 
@@ -416,7 +411,7 @@ static bool hive_setup_ldb(struct torture_context *tctx, void **data)
 
        rmdir(dirname);
 
-       error = reg_open_ldb_file(tctx, dirname, NULL, NULL, tctx->lp_ctx, &key);
+       error = reg_open_ldb_file(tctx, dirname, NULL, NULL, tctx->ev, tctx->lp_ctx, &key);
        if (!W_ERROR_IS_OK(error)) {
                fprintf(stderr, "Unable to initialize ldb hive\n");
                return false;
@@ -440,8 +435,7 @@ static bool hive_setup_regf(struct torture_context *tctx, void **data)
 
        rmdir(dirname);
 
-       error = reg_create_regf_file(tctx, lp_iconv_convenience(tctx->lp_ctx),
-                                    dirname, 5, &key);
+       error = reg_create_regf_file(tctx, dirname, 5, &key);
        if (!W_ERROR_IS_OK(error)) {
                fprintf(stderr, "Unable to create new regf file\n");
                return false;
@@ -463,7 +457,7 @@ static bool test_dir_refuses_null_location(struct torture_context *tctx)
 struct torture_suite *torture_registry_hive(TALLOC_CTX *mem_ctx)
 {
        struct torture_tcase *tcase;
-       struct torture_suite *suite = torture_suite_create(mem_ctx, "HIVE");
+       struct torture_suite *suite = torture_suite_create(mem_ctx, "hive");
 
        torture_suite_add_simple_test(suite, "dir-refuses-null-location",
                                      test_dir_refuses_null_location);