isomorfeus-ferret 0.17.2 → 0.17.3

data/ext/isomorfeus_ferret_ext/test_store.c

@@ -24,11 +24,10 @@ static void with_lock_test(void *p) {
     Assert(l->lock->is_locked(l->lock), "lock should be locked");
 }
 
-static void with_lock_name_test(void *p)
-{
+static void with_lock_name_test(void *p) {
     WithLockNameTestArg *l = (WithLockNameTestArg *)p;
     TestCase *tc = l->tc;
-    FrtLock *lock = frt_open_lock(l->store, l->lock_name);
+    FrtLock *lock = frt_open_lock(l->store, segm_idx_name, l->lock_name);
     Assert(lock->is_locked(lock), "lock should be locked");
     frt_close_lock(lock);
 }
@@ -36,22 +35,21 @@ static void with_lock_name_test(void *p)
 /**
  * Test that the lock is created and deleted correctly
  */
-static void test_lock(TestCase *tc, void *data)
-{
+static void test_lock(TestCase *tc, void *data) {
     FrtStore *store = (FrtStore *)data;
     FrtLock *lock, *lock1, *lock2;
     bool handled;
     WithLockTestArg wlta;
     WithLockNameTestArg wlnta;
 
-    lock1 = frt_open_lock(store, TEST_LOCK_NAME);
+    lock1 = frt_open_lock(store, segm_idx_name, TEST_LOCK_NAME);
     Aiequal(false, lock1->is_locked(lock1));
     Aiequal(true, lock1->obtain(lock1));
     Aiequal(true, lock1->is_locked(lock1));
     lock1->release(lock1);
     Aiequal(false, lock1->is_locked(lock1));
     Aiequal(true, lock1->obtain(lock1));
-    lock2 = frt_open_lock(store, TEST_LOCK_NAME);
+    lock2 = frt_open_lock(store, segm_idx_name, TEST_LOCK_NAME);
     Aiequal(true, lock2->is_locked(lock2));
     lock1->release(lock1);
     Aiequal(false, lock2->is_locked(lock2));
@@ -59,7 +57,7 @@ static void test_lock(TestCase *tc, void *data)
     frt_close_lock(lock2);
 
     /* test with_lock */
-    lock = frt_open_lock(store, TEST_LOCK_NAME);
+    lock = frt_open_lock(store, segm_idx_name, TEST_LOCK_NAME);
     Assert(!lock->is_locked(lock), "lock shouldn't be locked yet");
     wlta.lock = lock; wlta.tc = tc;
     frt_with_lock(lock, &with_lock_test, &wlta);
@@ -85,15 +83,15 @@ static void test_lock(TestCase *tc, void *data)
     frt_close_lock(lock);
 
     /* test with_lock_name */
-    lock = frt_open_lock(store, TEST_LOCK_NAME);
+    lock = frt_open_lock(store, segm_idx_name, TEST_LOCK_NAME);
     Assert(!lock->is_locked(lock), "lock shouldn't be locked yet");
     wlnta.lock_name = TEST_LOCK_NAME; wlnta.tc = tc; wlnta.store = store;
-    frt_with_lock_name(store, TEST_LOCK_NAME, &with_lock_name_test, &wlnta);
+    frt_with_lock_name(store, segm_idx_name, TEST_LOCK_NAME, &with_lock_name_test, &wlnta);
     Assert(!lock->is_locked(lock), "lock should be unlocked again");
     Assert(lock->obtain(lock), "lock should be obtainable");
     handled = false;
     FRT_TRY
-        frt_with_lock_name(store, TEST_LOCK_NAME, &with_lock_name_test, &wlnta);
+        frt_with_lock_name(store, segm_idx_name, TEST_LOCK_NAME, &with_lock_name_test, &wlnta);
         Assert(false, "A locking exception should have been raised");
         break;
     case FRT_LOCK_ERROR:
@@ -117,32 +115,31 @@ static void test_lock(TestCase *tc, void *data)
 static void test_basic_file_ops(TestCase *tc, void *data) {
     FrtStore *store = (FrtStore *)data;
 
-    store->clear_all(store);    /* Make sure the test directory is empty. */
-    Assert(!store->exists(store, "_1.f1"), "File1 should not been created yet");
-    store->touch(store, "_1.f1");
-    Aiequal(1, store->count(store));
-    Assert(store->count(store) == 1, "The store now contains one file");
-    Assert(store->exists(store, "_1.f1"), "File1 should now been created");
-    store->touch(store, "_1.f2");
-    Assert(store->count(store) == 2, "The store now contains two files");
-    Assert(store->exists(store, "_1.f2"), "File2 should now been created");
-    store->remove(store, "_1.f1");
-    Assert(store->count(store) == 1, "The store now contains one file");
-    Assert(!store->exists(store, "_1.f1"), "File1 should have been removed");
-    Assert(store->exists(store, "_1.f2"), "File2 should still exist");
+    store->clear_all(store, segm_idx_name);    /* Make sure the test directory is empty. */
+    Assert(!store->exists(store, segm_idx_name, "_1.f1"), "File1 should not been created yet");
+    store->touch(store, segm_idx_name, "_1.f1");
+    Aiequal(1, store->count(store, segm_idx_name));
+    Assert(store->count(store, segm_idx_name) == 1, "The store now contains one file");
+    Assert(store->exists(store, segm_idx_name, "_1.f1"), "File1 should now been created");
+    store->touch(store, segm_idx_name, "_1.f2");
+    Assert(store->count(store, segm_idx_name) == 2, "The store now contains two files");
+    Assert(store->exists(store, segm_idx_name, "_1.f2"), "File2 should now been created");
+    store->remove(store, segm_idx_name, "_1.f1");
+    Assert(store->count(store, segm_idx_name) == 1, "The store now contains one file");
+    Assert(!store->exists(store, segm_idx_name, "_1.f1"), "File1 should have been removed");
+    Assert(store->exists(store, segm_idx_name, "_1.f2"), "File2 should still exist");
 
     /* test that lock files get deleted by clear_all */
-    store->touch(store, "ferret-write.lck");
-    Assert(store->exists(store, "ferret-write.lck"),"lock should still exist");
-    store->clear_all(store);
-    Assert(!store->exists(store, "ferret-write.lck"), "lock should be deleted");
+    store->touch(store, segm_idx_name, "ferret-write.lck");
+    Assert(store->exists(store, segm_idx_name, "ferret-write.lck"),"lock should still exist");
+    store->clear_all(store, segm_idx_name);
+    Assert(!store->exists(store, segm_idx_name, "ferret-write.lck"), "lock should be deleted");
 }
 
 /**
  * Test argument used to test the store->each function
  */
-struct EachArg
-{
+struct EachArg {
     char str[100];
     char *p;
 };
@@ -150,8 +147,7 @@ struct EachArg
 /**
  * Test function used to test store->each function
  */
-static void concat_filenames(const char *fname, struct EachArg *ea)
-{
+static void concat_filenames(const char *fname, struct EachArg *ea) {
     strcpy(ea->p, fname);
     ea->p += strlen(fname);
 }
@@ -159,19 +155,18 @@ static void concat_filenames(const char *fname, struct EachArg *ea)
 /**
  * Test the store->each function
  */
-static void test_each(TestCase *tc, void *data)
-{
+static void test_each(TestCase *tc, void *data) {
     FrtStore *store = (FrtStore *)data;
 
     struct EachArg ea;
     ea.p = ea.str;
 
-    store->clear_all(store);    /* Make sure the test directory is empty. */
-    store->touch(store, "_1.f1");
-    store->touch(store, "_1.f2");
-    store->touch(store, "_1.f3");
-    store->touch(store, "_1.f4");
-    store->each(store, (void(*)(const char *fname, void *arg))&concat_filenames, &ea);
+    store->clear_all(store, segm_idx_name);    /* Make sure the test directory is empty. */
+    store->touch(store, segm_idx_name, "_1.f1");
+    store->touch(store, segm_idx_name, "_1.f2");
+    store->touch(store, segm_idx_name, "_1.f3");
+    store->touch(store, segm_idx_name, "_1.f4");
+    store->each(store, segm_idx_name, (void(*)(const char *fname, void *arg))&concat_filenames, &ea);
     *(ea.p) = 0;
     Assert(strstr(ea.str, "_1.f1") != NULL, "should contain this file");
     Assert(strstr(ea.str, "_1.f2") != NULL, "should contain this file");
@@ -183,54 +178,52 @@ static void test_each(TestCase *tc, void *data)
 /**
  * Test the store->rename function
  */
-static void test_rename(TestCase *tc, void *data)
-{
+static void test_rename(TestCase *tc, void *data) {
     int cnt_before, cnt_after;
     FrtStore *store = (FrtStore *)data;
-    store->touch(store, "_from.f1");
-    Assert(store->exists(store, "_from.f1"), "File should exist");
-    Assert(!store->exists(store, "_to.f1"), "File should not exist");
-    cnt_before = store->count(store);
-    store->rename(store, "_from.f1", "_to.f1");
-    cnt_after = store->count(store);
+    store->touch(store, segm_idx_name, "_from.f1");
+    Assert(store->exists(store, segm_idx_name, "_from.f1"), "File should exist");
+    Assert(!store->exists(store, segm_idx_name, "_to.f1"), "File should not exist");
+    cnt_before = store->count(store, segm_idx_name);
+    store->rename(store, segm_idx_name, "_from.f1", "_to.f1");
+    cnt_after = store->count(store, segm_idx_name);
     Aiequal(cnt_before, cnt_after);
-    Assert(store->exists(store, "_to.f1"), "File should now exist");
-    Assert(!store->exists(store, "_from.f1"), "File should no longer exist");
+    Assert(store->exists(store, segm_idx_name, "_to.f1"), "File should now exist");
+    Assert(!store->exists(store, segm_idx_name, "_from.f1"), "File should no longer exist");
 }
 
 /**
  * Test the reading and writing of bytes (8 bit)
  */
-static void test_rw_bytes(TestCase *tc, void *data)
-{
+static void test_rw_bytes(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     frt_uchar bytes[6] = { 0x34, 0x87, 0xF9, 0xEA, 0x00, 0xFF };
-    FrtOutStream *ostream = store->new_output(store, "_rw_byte.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_byte.fdt");
     FrtInStream *istream;
-    Assert(store->exists(store, "_rw_byte.cfs"), "File should now exist");
+    
     for (i = 0; i < 6; i++) {
         frt_os_write_byte(ostream, bytes[i]);
     }
     frt_os_close(ostream);
+    Assert(store->exists(store, segm_idx_name, "_rw_byte.fdt"), "File should now exist");
 
-    istream = store->open_input(store, "_rw_byte.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_byte.fdt");
     for (i = 0; i < 6; i++) {
         Aiequal(bytes[i], frt_is_read_byte(istream));
     }
     frt_is_close(istream);
-    Aiequal(6, store->length(store, "_rw_byte.cfs"));
-    Assert(store->exists(store, "_rw_byte.cfs"), "File should now exist");
+    Aiequal(6, store->length(store, segm_idx_name, "_rw_byte.fdt"));
+    Assert(store->exists(store, segm_idx_name, "_rw_byte.fdt"), "File should now exist");
 }
 
 /**
  * Test the reading and writing of 32-bit integers
  */
-static void test_rw_i32(TestCase *tc, void *data)
-{
+static void test_rw_i32(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
-    FrtOutStream *ostream = store->new_output(store, "_rw_int.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_int.fdt");
     FrtInStream *istream;
     frt_i32 ints[4] = { POSH_I32_MAX, POSH_I32_MIN, -1, 0 };
 
@@ -239,25 +232,24 @@ static void test_rw_i32(TestCase *tc, void *data)
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_int.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_int.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(ints[i], frt_is_read_i32(istream));
     }
 
     frt_is_close(istream);
-    Aiequal(16, store->length(store, "_rw_int.cfs"));
+    Aiequal(16, store->length(store, segm_idx_name, "_rw_int.fdt"));
 }
 
 /**
  * Test the reading and writing of 64-bit integers
  */
-static void test_rw_i64(TestCase *tc, void *data)
-{
+static void test_rw_i64(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     frt_u64 longs[4] =
         { POSH_I64_MIN, POSH_I64_MAX, POSH_I64(-1), POSH_I64(0) };
-    FrtOutStream *ostream = store->new_output(store, "_rw_long.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_long.fdt");
     FrtInStream *istream;
 
     for (i = 0; i < 4; i++) {
@@ -265,23 +257,22 @@ static void test_rw_i64(TestCase *tc, void *data)
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_long.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_long.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(longs[i], frt_is_read_i64(istream));
     }
     frt_is_close(istream);
-    Aiequal(32, store->length(store, "_rw_long.cfs"));
+    Aiequal(32, store->length(store, segm_idx_name, "_rw_long.fdt"));
 }
 
 /**
  * Test the reading and writing of 32-bit unsigned integers
  */
-static void test_rw_u32(TestCase *tc, void *data)
-{
+static void test_rw_u32(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     frt_u32 uints[4] = { POSH_U32_MAX, POSH_U32_MIN, 100000, 1 };
-    FrtOutStream *ostream = store->new_output(store, "_rw_uint.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_uint.fdt");
     FrtInStream *istream;
 
     for (i = 0; i < 4; i++) {
@@ -289,24 +280,23 @@ static void test_rw_u32(TestCase *tc, void *data)
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_uint.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_uint.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(uints[i], frt_is_read_u32(istream));
     }
     frt_is_close(istream);
-    Aiequal(16, store->length(store, "_rw_uint.cfs"));
+    Aiequal(16, store->length(store, segm_idx_name, "_rw_uint.fdt"));
 }
 
 /**
  * Test the reading and writing of 64-bit unsigned integers
  */
-static void test_rw_u64(TestCase *tc, void *data)
-{
+static void test_rw_u64(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     frt_u64 ulongs[4] =
         { POSH_U64_MAX, POSH_U64_MIN, POSH_U64(100000000000000), POSH_U64(1) };
-    FrtOutStream *ostream = store->new_output(store, "_rw_ulong.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_ulong.fdt");
     FrtInStream *istream;
 
     for (i = 0; i < 4; i++) {
@@ -314,23 +304,22 @@ static void test_rw_u64(TestCase *tc, void *data)
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_ulong.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_ulong.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(ulongs[i], frt_is_read_u64(istream));
     }
     frt_is_close(istream);
-    Aiequal(32, store->length(store, "_rw_ulong.cfs"));
+    Aiequal(32, store->length(store, segm_idx_name, "_rw_ulong.fdt"));
 }
 
 /**
  * Test reading and writing of variable size integers
  */
-static void test_rw_vints(TestCase *tc, void *data)
-{
+static void test_rw_vints(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     unsigned int vints[4] = { UINT_MAX, 0, 10000, 1 };
-    FrtOutStream *ostream = store->new_output(store, "_rw_vint.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_vint.fdt");
     FrtInStream *istream;
 
     for (i = 0; i < 4; i++) {
@@ -338,7 +327,7 @@ static void test_rw_vints(TestCase *tc, void *data)
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_vint.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_vint.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(vints[i], frt_is_read_vint(istream));
     }
@@ -348,12 +337,11 @@ static void test_rw_vints(TestCase *tc, void *data)
 /**
  * Test reading and writing of variable size integers
  */
-static void test_rw_vlls(TestCase *tc, void *data)
-{
+static void test_rw_vlls(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     unsigned long long vlls[4] = { ULLONG_MAX, 0, 10000, 1 };
-    FrtOutStream *ostream = store->new_output(store, "_rw_vll.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_vll.fdt");
     FrtInStream *istream;
 
     for (i = 0; i < 4; i++) {
@@ -361,7 +349,7 @@ static void test_rw_vlls(TestCase *tc, void *data)
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_vll.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_vll.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(vlls[i], frt_is_read_vll(istream));
     }
@@ -371,8 +359,7 @@ static void test_rw_vlls(TestCase *tc, void *data)
 /**
  * Test reading and writing of variable size 64-bit integers
  */
-static void test_rw_voff_ts(TestCase *tc, void *data)
-{
+static void test_rw_voff_ts(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     FrtOutStream *ostream;
@@ -381,18 +368,17 @@ static void test_rw_voff_ts(TestCase *tc, void *data)
         { LONG_MAX, 0, 1000000, 1 };
     if (sizeof(off_t) == 8) {
         voff_ts[0] = POSH_I64_MAX;
-    }
-    else {
+    } else {
         voff_ts[0] = POSH_I32_MAX;
     }
-    ostream = store->new_output(store, "_rw_voff_t.cfs");
+    ostream = store->new_output(store, segm_idx_name, "_rw_voff_t.fdt");
 
     for (i = 0; i < 4; i++) {
         frt_os_write_voff_t(ostream, (off_t)voff_ts[i]);
     }
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_voff_t.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_voff_t.fdt");
     for (i = 0; i < 4; i++) {
         Aiequal(voff_ts[i], frt_is_read_voff_t(istream));
     }
@@ -402,8 +388,7 @@ static void test_rw_voff_ts(TestCase *tc, void *data)
 /**
  * Test reading and writing of strings
  */
-static void test_rw_strings(TestCase *tc, void *data)
-{
+static void test_rw_strings(TestCase *tc, void *data) {
     int i;
     char *tmp;
     FrtStore *store = (FrtStore *)data;
@@ -417,12 +402,12 @@ static void test_rw_strings(TestCase *tc, void *data)
         strcat(buf, str);
     }
 
-    ostream = store->new_output(store, "_rw_string.cfs");
+    ostream = store->new_output(store, segm_idx_name, "_rw_string.fdt");
     frt_os_write_string(ostream, str);
     frt_os_write_string(ostream, buf);
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_string.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_string.fdt");
 
     tmp = frt_is_read_string(istream);
     Asequal(str, tmp);
@@ -431,14 +416,13 @@ static void test_rw_strings(TestCase *tc, void *data)
     Asequal(buf, tmp);
     free(tmp);
     frt_is_close(istream);
-    Aiequal(59063, store->length(store, "_rw_string.cfs"));
+    Aiequal(59063, store->length(store, segm_idx_name, "_rw_string.fdt"));
 }
 
 /**
  * Test reading and writing of non-ascii characters
  */
-static void test_rw_funny_strings(TestCase *tc, void *data)
-{
+static void test_rw_funny_strings(TestCase *tc, void *data) {
     int i;
     char *tmp;
     FrtStore *store = (FrtStore *)data;
@@ -451,12 +435,12 @@ static void test_rw_funny_strings(TestCase *tc, void *data)
         strcat(buf, str);
     }
 
-    ostream = store->new_output(store, "_funny_string.cfs");
+    ostream = store->new_output(store, segm_idx_name, "_funny_string.fdt");
     frt_os_write_string(ostream, str);
     frt_os_write_string(ostream, buf);
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_funny_string.cfs");
+    istream = store->open_input(store, segm_idx_name, "_funny_string.fdt");
     tmp = frt_is_read_string(istream);
     Asequal(str, tmp);
     free(tmp);
@@ -464,19 +448,18 @@ static void test_rw_funny_strings(TestCase *tc, void *data)
     Asequal(buf, tmp);
     free(tmp);
     frt_is_close(istream);
-    Aiequal(17021, store->length(store, "_funny_string.cfs"));
+    Aiequal(17021, store->length(store, segm_idx_name, "_funny_string.fdt"));
 }
 
 /**
  * Test seek in both input stream and output stream, ie test the frt_os_seek and
  * frt_is_seek functions
  */
-static void test_buffer_seek(TestCase *tc, void *data)
-{
+static void test_buffer_seek(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
 
-    FrtOutStream *ostream = store->new_output(store, "_rw_seek.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_rw_seek.fdt");
     char text[60] = "This is another int test string !@#$%#$%&%$*%^&*()(_";
     FrtInStream *istream;
 
@@ -495,7 +478,7 @@ static void test_buffer_seek(TestCase *tc, void *data)
     frt_os_write_voff_t(ostream, 98763210);
     frt_os_close(ostream);
 
-    istream = store->open_input(store, "_rw_seek.cfs");
+    istream = store->open_input(store, segm_idx_name, "_rw_seek.fdt");
     frt_is_seek(istream, 56);
     Aiequal(56, frt_is_pos(istream));
     Aiequal(12345, frt_is_read_vint(istream));
@@ -511,18 +494,17 @@ static void test_buffer_seek(TestCase *tc, void *data)
 /**
  * Test cloning of InputStream
  */
-static void test_is_clone(TestCase *tc, void *data)
-{
+static void test_is_clone(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
-    FrtOutStream *ostream = store->new_output(store, "_clone.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_clone.fdt");
     FrtInStream *istream, *alt_istream;
 
     for (i = 0; i < 10; i++) {
         frt_os_write_i64(ostream, i);
     }
     frt_os_close(ostream);
-    istream = store->open_input(store, "_clone.cfs");
+    istream = store->open_input(store, segm_idx_name, "_clone.fdt");
     frt_is_seek(istream, 24);
     alt_istream = frt_is_clone(istream);
     Aiequal(frt_is_pos(istream), frt_is_pos(alt_istream));
@@ -542,16 +524,15 @@ static void test_is_clone(TestCase *tc, void *data)
  * Test the read_bytes method. This method reads a number of bytes into a
  * buffer.
  */
-static void test_read_bytes(TestCase *tc, void *data)
-{
+static void test_read_bytes(TestCase *tc, void *data) {
     char str[11] = "0000000000";
     FrtStore *store = (FrtStore *)data;
-    FrtOutStream *ostream = store->new_output(store, "_read_bytes.cfs");
+    FrtOutStream *ostream = store->new_output(store, segm_idx_name, "_read_bytes.fdt");
     FrtInStream *istream;
 
     frt_os_write_bytes(ostream, (frt_uchar *)"how are you doing?", 18);
     frt_os_close(ostream);
-    istream = store->open_input(store, "_read_bytes.cfs");
+    istream = store->open_input(store, segm_idx_name, "_read_bytes.fdt");
     frt_is_read_bytes(istream, (frt_uchar *)(str + 2), 4);
     Asequal("00how 0000", str);
     frt_is_read_bytes(istream, (frt_uchar *)(str + 1), 8);
@@ -565,7 +546,7 @@ static void test_read_bytes(TestCase *tc, void *data)
  * store that you might want to create.
  */
 void create_test_store_suite(TestSuite *suite, FrtStore *store) {
-    store->clear_all(store);
+    store->clear_all(store, segm_idx_name);
 
     tst_run_test(suite, test_basic_file_ops, store);
     tst_run_test(suite, test_rename, store);
@@ -585,5 +566,5 @@ void create_test_store_suite(TestSuite *suite, FrtStore *store) {
     tst_run_test(suite, test_read_bytes, store);
     tst_run_test(suite, test_lock, store);
 
-    store->clear_all(store);
+    store->clear_all(store, segm_idx_name);
 }

data/ext/isomorfeus_ferret_ext/test_term.c

@@ -60,8 +60,7 @@ static const char *DICT[DICT_LEN] = {
 };
 
 /*
-static char *rev(char *str)
-{
+static char *rev(char *str) {
     char *rev = frt_estrdup(str);
     int i, j;
     for (i = 0, j = (int)strlen(str)-1; i < j; i++, j--) {
@@ -78,8 +77,7 @@ static char *rev(char *str)
  *
  *****************************************************************************/
 
-static void test_segment_field_index_single_field(TestCase *tc, void *data)
-{
+static void test_segment_field_index_single_field(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     FrtSegmentFieldIndex *sfi;
@@ -107,8 +105,7 @@ static void test_segment_field_index_single_field(TestCase *tc, void *data)
     frt_sfi_close(sfi);
 }
 
-static void add_multi_field_terms(FrtStore *store)
-{
+static void add_multi_field_terms(FrtStore *store) {
     int i;
     int field_num = 0;
     FrtTermInfosWriter *tiw = frt_tiw_open(store, "_0", 8, 8);
@@ -124,8 +121,7 @@ static void add_multi_field_terms(FrtStore *store)
     frt_tiw_close(tiw);
 }
 
-static void test_segment_field_index_multi_field(TestCase *tc, void *data)
-{
+static void test_segment_field_index_multi_field(TestCase *tc, void *data) {
     FrtStore *store = (FrtStore *)data;
     FrtSegmentFieldIndex *sfi;
     FrtSegmentTermIndex *sti;
@@ -153,8 +149,7 @@ static void test_segment_field_index_multi_field(TestCase *tc, void *data)
     frt_sfi_close(sfi);
 }
 
-void test_segment_term_enum(TestCase *tc, void *data)
-{
+void test_segment_term_enum(TestCase *tc, void *data) {
     int i;
     FrtStore *store = (FrtStore *)data;
     FrtSegmentFieldIndex *sfi;
@@ -163,7 +158,7 @@ void test_segment_term_enum(TestCase *tc, void *data)
     add_multi_field_terms(store);
 
     sfi = frt_sfi_open(store, "_0");
-    FrtInStream *is = store->open_input(store, "_0.tis");
+    FrtInStream *is = store->open_input(store, segm_idx_name, "_0.tis");
     FRT_DEREF(is);
     te = frt_ste_new(is, sfi);
     te->set_field(te, 0);
@@ -284,8 +279,7 @@ void test_segment_term_enum(TestCase *tc, void *data)
     frt_sfi_close(sfi);
 }
 
-static void test_term_infos_reader(TestCase *tc, void *data)
-{
+static void test_term_infos_reader(TestCase *tc, void *data) {
     FrtStore *store = (FrtStore *)data;
     FrtSegmentFieldIndex *sfi;
     FrtTermInfosReader *tir;
@@ -338,9 +332,9 @@ static void test_term_infos_reader(TestCase *tc, void *data)
     frt_sfi_close(sfi);
 }
 
-TestSuite *ts_term(TestSuite *suite)
-{
+TestSuite *ts_term(TestSuite *suite) {
     FrtStore *store = frt_open_ram_store(NULL);
+    store->create_folder(store, segm_idx_name);
 
     suite = ADD_SUITE(suite);