isomorfeus-ferret 0.17.2 → 0.17.4

data/ext/isomorfeus_ferret_ext/test_sort.c

@@ -16,14 +16,13 @@ typedef struct SortTestData {
     const char *flt;
 } SortTestData;
 
-static void add_sort_test_data(SortTestData *std, FrtIndexWriter *iw)
-{
+static void add_sort_test_data(SortTestData *std, FrtIndexWriter *iw) {
     FrtDocument *doc = frt_doc_new();
     rb_encoding *enc = rb_enc_find("ASCII-8BIT");
-    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(search), (char *)std->search, enc));
-    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(string), (char *)std->string, enc));
-    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(integer), (char *)std->integer, enc));
-    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(flt), (char *)std->flt, enc));
+    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(search), std->search, enc));
+    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(string), std->string, enc));
+    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(integer), std->integer, enc));
+    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(flt), std->flt, enc));
 
     sscanf(std->flt, "%f", &doc->boost);
 
@@ -44,8 +43,7 @@ static SortTestData data[] = {     /* len mod */
     {"findall","b","4","0.000001"} /*  8   0  */
 };
 
-static void sort_test_setup(FrtStore *store)
-{
+static void sort_test_setup(FrtStore *store) {
     int i;
     FrtIndexWriter *iw;
     FrtFieldInfos *fis = frt_fis_new(0 | FRT_FI_IS_STORED_BM | FRT_FI_IS_INDEXED_BM | FRT_FI_IS_TOKENIZED_BM | FRT_FI_STORE_TERM_VECTOR_BM);
@@ -60,8 +58,7 @@ static void sort_test_setup(FrtStore *store)
     frt_iw_close(iw);
 }
 
-static void sort_multi_test_setup(FrtStore *store1, FrtStore *store2)
-{
+static void sort_multi_test_setup(FrtStore *store1, FrtStore *store2) {
     int i;
     FrtFieldInfos *fis = frt_fis_new(0 | FRT_FI_IS_STORED_BM | FRT_FI_IS_INDEXED_BM | FRT_FI_IS_TOKENIZED_BM | FRT_FI_STORE_TERM_VECTOR_BM);
     FrtIndexWriter *iw;
@@ -87,8 +84,7 @@ static void sort_multi_test_setup(FrtStore *store1, FrtStore *store2)
 
 #define R_START 3
 #define R_END 6
-static void do_test_top_docs(TestCase *tc, FrtSearcher *searcher, FrtQuery *query, const char *expected_hits, FrtSort *sort)
-{
+static void do_test_top_docs(TestCase *tc, FrtSearcher *searcher, FrtQuery *query, const char *expected_hits, FrtSort *sort) {
     static int num_array[ARRAY_SIZE];
     int i;
     int total_hits = s2l(expected_hits, num_array);
@@ -101,7 +97,7 @@ static void do_test_top_docs(TestCase *tc, FrtSearcher *searcher, FrtQuery *quer
         if (false && sort && searcher->doc_freq != frt_isea_doc_freq) {
             FrtFieldDoc *fd = (FrtFieldDoc *)hit;
             int j;
-            printf("%d == %d:%f ", num_array[i], hit->doc, hit->score);
+            printf("%d == %d:%f ", num_array[i], hit->doc_num, hit->score);
             for (j = 0; j < fd->size; j++) {
                 switch (fd->comparables[j].type) {
                     case FRT_SORT_TYPE_SCORE:
@@ -120,7 +116,7 @@ static void do_test_top_docs(TestCase *tc, FrtSearcher *searcher, FrtQuery *quer
             }
             printf("\n");
         }
-        Aiequal(num_array[i], hit->doc);
+        Aiequal(num_array[i], hit->doc_num);
     }
     frt_td_destroy(top_docs);
 
@@ -128,7 +124,7 @@ static void do_test_top_docs(TestCase *tc, FrtSearcher *searcher, FrtQuery *quer
         top_docs = frt_searcher_search(searcher, query, R_START, R_END - R_START, NULL, sort, NULL);
         for (i = R_START; i < R_END; i++) {
             FrtHit *hit = top_docs->hits[i - R_START];
-            Aiequal(num_array[i], hit->doc);
+            Aiequal(num_array[i], hit->doc_num);
             /*
             printf("%d == %d\n", num_array[i], hit->doc);
             */
@@ -147,8 +143,7 @@ static void do_test_top_docs(TestCase *tc, FrtSearcher *searcher, FrtQuery *quer
     } while (0)
 
 
-static void test_sort_field_to_s(TestCase *tc, void *data)
-{
+static void test_sort_field_to_s(TestCase *tc, void *data) {
     (void)data;
     TEST_SF_TO_S("<SCORE>", frt_sort_field_score_new(false));
     TEST_SF_TO_S("<SCORE>!", frt_sort_field_score_new(true));
@@ -171,8 +166,7 @@ static void test_sort_field_to_s(TestCase *tc, void *data)
         free(_str);\
     } while (0)
 
-static void test_sort_to_s(TestCase *tc, void *data)
-{
+static void test_sort_to_s(TestCase *tc, void *data) {
     FrtSort *sort = frt_sort_new();
     (void)data;
 
@@ -198,8 +192,7 @@ static void test_sort_to_s(TestCase *tc, void *data)
 }
 
 static bool do_byte_test = true;
-static void test_sorts(TestCase *tc, void *data)
-{
+static void test_sorts(TestCase *tc, void *data) {
     FrtSearcher *sea = (FrtSearcher *)data;
     FrtQuery *q;
     FrtSort *sort = NULL;
@@ -288,10 +281,10 @@ static void test_sorts(TestCase *tc, void *data)
     frt_q_deref(q);
 }
 
-TestSuite *ts_sort(TestSuite *suite)
-{
+TestSuite *ts_sort(TestSuite *suite) {
     FrtSearcher *sea, **searchers;
     FrtStore *store = frt_open_ram_store(NULL), *fs_store;
+    store->create_folder(store, segm_idx_name);
     FrtIndexReader *ir0;
     FrtIndexReader *ir1;
 
@@ -317,11 +310,8 @@ TestSuite *ts_sort(TestSuite *suite)
 
     do_byte_test = false;
 
-#if defined POSH_OS_WIN32 || defined POSH_OS_WIN64
-    fs_store = frt_open_mdbx_store(".\\test\\testdir\\store");
-#else
     fs_store = frt_open_mdbx_store("./test/testdir/store");
-#endif
+
     sort_multi_test_setup(store, fs_store);
 
     searchers = FRT_ALLOC_N(FrtSearcher *, 2);

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);
 }