tdb2: make tdb1_open use attributes for logging, hash function.

[ccan] / ccan / tdb2 / test / run-tdb1-incompatible.c

diff --git a/ccan/tdb2/test/run-tdb1-incompatible.c b/ccan/tdb2/test/run-tdb1-incompatible.c
index 9e581614622bd9f60a295a9869fb205527fca867..baf40ed4e68cd78cae66c47f70d65f17c9113b34 100644 (file)
--- a/ccan/tdb2/test/run-tdb1-incompatible.c
+++ b/ccan/tdb2/test/run-tdb1-incompatible.c
@@ -49,7 +49,29 @@ int main(int argc, char *argv[])
        struct tdb_context *tdb;
        unsigned int log_count, flags;
        TDB_DATA d;
-       struct tdb1_logging_context log_ctx = { log_fn, &log_count };
+       union tdb_attribute log_attr, jhash_attr, ohash_attr,
+               incompat_hash_attr, dumbhash_attr;
+
+       log_attr.base.attr = TDB_ATTRIBUTE_LOG;
+       log_attr.base.next = NULL;
+       log_attr.log.fn = log_fn;
+       log_attr.log.data = &log_count;
+
+       jhash_attr.base.attr = TDB_ATTRIBUTE_HASH;
+       jhash_attr.base.next = &log_attr;
+       jhash_attr.hash.fn = jenkins_hashfn;
+
+       ohash_attr.base.attr = TDB_ATTRIBUTE_HASH;
+       ohash_attr.base.next = &log_attr;
+       ohash_attr.hash.fn = old_hash;
+
+       incompat_hash_attr.base.attr = TDB_ATTRIBUTE_HASH;
+       incompat_hash_attr.base.next = &log_attr;
+       incompat_hash_attr.hash.fn = tdb1_incompatible_hash;
+
+       dumbhash_attr.base.attr = TDB_ATTRIBUTE_HASH;
+       dumbhash_attr.base.next = &log_attr;
+       dumbhash_attr.hash.fn = tdb1_dumb_hash;
 
        plan_tests(38 * 2);
 
@@ -61,9 +83,8 @@ int main(int argc, char *argv[])
 
                /* Create an old-style hash. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0, flags,
-                                 O_CREAT|O_RDWR|O_TRUNC, 0600, &log_ctx,
-                                 NULL);
+               tdb = tdb1_open("run-incompatible.tdb", 0, flags,
+                               O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
@@ -76,10 +97,9 @@ int main(int argc, char *argv[])
 
                /* We can still open any old-style with incompat hash. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0,
-                                 TDB_DEFAULT,
-                                 O_RDWR, 0600, &log_ctx,
-                                  tdb1_incompatible_hash);
+               tdb = tdb1_open("run-incompatible.tdb", 0,
+                               TDB_DEFAULT,
+                               O_RDWR, 0600, &incompat_hash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d = tdb1_fetch(tdb, d);
@@ -89,16 +109,16 @@ int main(int argc, char *argv[])
                tdb1_close(tdb);
 
                log_count = 0;
-               tdb = tdb1_open_ex("test/jenkins-le-hash.tdb1", 0, 0, O_RDONLY,
-                                 0, &log_ctx, jenkins_hashfn);
+               tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, 0, O_RDONLY,
+                               0, &jhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
                tdb1_close(tdb);
 
                log_count = 0;
-               tdb = tdb1_open_ex("test/jenkins-be-hash.tdb1", 0, 0, O_RDONLY,
-                                 0, &log_ctx, jenkins_hashfn);
+               tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, 0, O_RDONLY,
+                               0, &jhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
@@ -106,10 +126,10 @@ int main(int argc, char *argv[])
 
                /* OK, now create with incompatible hash. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0,
-                                 flags,
-                                 O_CREAT|O_RDWR|O_TRUNC, 0600, &log_ctx,
-                                 tdb1_incompatible_hash);
+               tdb = tdb1_open("run-incompatible.tdb", 0,
+                               flags,
+                               O_CREAT|O_RDWR|O_TRUNC, 0600,
+                               &incompat_hash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
@@ -122,15 +142,15 @@ int main(int argc, char *argv[])
 
                /* Cannot open with old hash. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0, 0,
-                                 O_RDWR, 0600, &log_ctx, old_hash);
+               tdb = tdb1_open("run-incompatible.tdb", 0, 0,
+                               O_RDWR, 0600, &ohash_attr);
                ok1(!tdb);
                ok1(log_count == 1);
 
                /* Can open with jenkins hash. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0, 0,
-                                 O_RDWR, 0600, &log_ctx, jenkins_hashfn);
+               tdb = tdb1_open("run-incompatible.tdb", 0, 0,
+                               O_RDWR, 0600, &jhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d = tdb1_fetch(tdb, d);
@@ -141,8 +161,8 @@ int main(int argc, char *argv[])
 
                /* Can open by letting it figure it out itself. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0, 0,
-                                 O_RDWR, 0600, &log_ctx, NULL);
+               tdb = tdb1_open("run-incompatible.tdb", 0, 0,
+                               O_RDWR, 0600, &log_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
@@ -156,10 +176,9 @@ int main(int argc, char *argv[])
                /* FIXME: Not possible with TDB2 :( */
                /* We can also use incompatible hash with other hashes. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0,
-                                 flags,
-                                 O_CREAT|O_RDWR|O_TRUNC, 0600, &log_ctx,
-                                 tdb1_dumb_hash);
+               tdb = tdb1_open("run-incompatible.tdb", 0,
+                               flags,
+                               O_CREAT|O_RDWR|O_TRUNC, 0600, &dumbhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
@@ -172,15 +191,15 @@ int main(int argc, char *argv[])
 
                /* It should not open if we don't specify. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0, 0, O_RDWR, 0,
-                                 &log_ctx, NULL);
+               tdb = tdb1_open("run-incompatible.tdb", 0, 0, O_RDWR, 0,
+                               &log_attr);
                ok1(!tdb);
                ok1(log_count == 1);
 
                /* Should reopen with correct hash. */
                log_count = 0;
-               tdb = tdb1_open_ex("run-incompatible.tdb", 0, 0, O_RDWR, 0,
-                                 &log_ctx, tdb1_dumb_hash);
+               tdb = tdb1_open("run-incompatible.tdb", 0, 0, O_RDWR, 0,
+                               &dumbhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d = tdb1_fetch(tdb, d);