tdb2: unify tdb1_open into tdb_open

[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 48f796dbf484cc45e193b5937d6918335445ac61..350c78b2b4f12f881fbba41b203eea2d72408d94 100644 (file)
--- a/ccan/tdb2/test/run-tdb1-incompatible.c
+++ b/ccan/tdb2/test/run-tdb1-incompatible.c
@@ -83,86 +83,86 @@ int main(int argc, char *argv[])
 
                /* Create an old-style hash. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb", flags,
-                               O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
+               tdb = tdb_open("run-incompatible.tdb1", flags|TDB_VERSION1,
+                              O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
                d.dsize = 5;
                ok1(tdb1_store(tdb, d, d, TDB_INSERT) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                /* Should not have marked rwlocks field. */
-               ok1(hdr_rwlocks("run-incompatible.tdb") == 0);
+               ok1(hdr_rwlocks("run-incompatible.tdb1") == 0);
 
                /* We can still open any old-style with incompat hash. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb",
-                               TDB_DEFAULT,
-                               O_RDWR, 0600, &incompat_hash_attr);
+               tdb = tdb_open("run-incompatible.tdb1",
+                              TDB_VERSION1,
+                              O_RDWR, 0600, &incompat_hash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d = tdb1_fetch(tdb, d);
                ok1(d.dsize == 5);
                free(d.dptr);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                log_count = 0;
-               tdb = tdb1_open("test/jenkins-le-hash.tdb1", 0, O_RDONLY,
-                               0, &jhash_attr);
+               tdb = tdb_open("test/jenkins-le-hash.tdb1",
+                              TDB_VERSION1, O_RDONLY, 0, &jhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                log_count = 0;
-               tdb = tdb1_open("test/jenkins-be-hash.tdb1", 0, O_RDONLY,
-                               0, &jhash_attr);
+               tdb = tdb_open("test/jenkins-be-hash.tdb1",
+                              TDB_VERSION1, O_RDONLY, 0, &jhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                /* OK, now create with incompatible hash. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb",
-                               flags,
-                               O_CREAT|O_RDWR|O_TRUNC, 0600,
-                               &incompat_hash_attr);
+               tdb = tdb_open("run-incompatible.tdb1",
+                              flags|TDB_VERSION1,
+                              O_CREAT|O_RDWR|O_TRUNC, 0600,
+                              &incompat_hash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
                d.dsize = 5;
                ok1(tdb1_store(tdb, d, d, TDB_INSERT) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                /* Should have marked rwlocks field. */
-               ok1(hdr_rwlocks("run-incompatible.tdb") == rwmagic);
+               ok1(hdr_rwlocks("run-incompatible.tdb1") == rwmagic);
 
                /* Cannot open with old hash. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb", 0,
-                               O_RDWR, 0600, &ohash_attr);
+               tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1,
+                              O_RDWR, 0600, &ohash_attr);
                ok1(!tdb);
                ok1(log_count == 1);
 
                /* Can open with jenkins hash. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb", 0,
-                               O_RDWR, 0600, &jhash_attr);
+               tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1,
+                              O_RDWR, 0600, &jhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d = tdb1_fetch(tdb, d);
                ok1(d.dsize == 5);
                free(d.dptr);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                /* Can open by letting it figure it out itself. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb", 0,
-                               O_RDWR, 0600, &log_attr);
+               tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1,
+                              O_RDWR, 0600, &log_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
@@ -171,42 +171,42 @@ int main(int argc, char *argv[])
                ok1(d.dsize == 5);
                free(d.dptr);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                /* FIXME: Not possible with TDB2 :( */
                /* We can also use incompatible hash with other hashes. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb",
-                               flags,
-                               O_CREAT|O_RDWR|O_TRUNC, 0600, &dumbhash_attr);
+               tdb = tdb_open("run-incompatible.tdb1",
+                              flags|TDB_VERSION1,
+                              O_CREAT|O_RDWR|O_TRUNC, 0600, &dumbhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d.dptr = (void *)"Hello";
                d.dsize = 5;
                ok1(tdb1_store(tdb, d, d, TDB_INSERT) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
 
                /* FIXME: Should have marked rwlocks field. */
-               ok1(hdr_rwlocks("run-incompatible.tdb") != rwmagic);
+               ok1(hdr_rwlocks("run-incompatible.tdb1") != rwmagic);
 
                /* It should not open if we don't specify. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb", 0, O_RDWR, 0,
-                               &log_attr);
+               tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1, O_RDWR, 0,
+                              &log_attr);
                ok1(!tdb);
                ok1(log_count == 1);
 
                /* Should reopen with correct hash. */
                log_count = 0;
-               tdb = tdb1_open("run-incompatible.tdb", 0, O_RDWR, 0,
-                               &dumbhash_attr);
+               tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1, O_RDWR, 0,
+                              &dumbhash_attr);
                ok1(tdb);
                ok1(log_count == 0);
                d = tdb1_fetch(tdb, d);
                ok1(d.dsize == 5);
                free(d.dptr);
                ok1(tdb1_check(tdb, NULL, NULL) == 0);
-               tdb1_close(tdb);
+               tdb_close(tdb);
        }
 
        return exit_status();