isomorfeus-ferret 0.12.0

data/ext/isomorfeus_ferret_ext/test_compound_io.c

@@ -0,0 +1,170 @@
+#include "frt_store.h"
+#include "frt_index.h"
+#include "testhelper.h"
+#include "test.h"
+
+void test_compound_reader(TestCase *tc, void *data)
+{
+    FrtStore *store = (FrtStore *)data;
+    char *p;
+    FrtOutStream *os = store->new_output(store, "cfile");
+    FrtInStream *is1;
+    FrtInStream *is2;
+    FrtStore *c_reader;
+    frt_os_write_vint(os, 2);
+    frt_os_write_u64(os, 29);
+    frt_os_write_string(os, "file1");
+    frt_os_write_u64(os, 33);
+    frt_os_write_string(os, "file2");
+    frt_os_write_u32(os, 20);
+    frt_os_write_string(os, "this is file 2");
+    frt_os_close(os);
+
+    c_reader = frt_open_cmpd_store(store, "cfile");
+    Aiequal(4, c_reader->length(c_reader, "file1"));
+    Aiequal(15, c_reader->length(c_reader, "file2"));
+    is1 = c_reader->open_input(c_reader, "file1");
+    is2 = c_reader->open_input(c_reader, "file2");
+    Aiequal(20, frt_is_read_u32(is1));
+    Asequal("this is file 2", p = frt_is_read_string(is2)); free(p);
+    frt_is_close(is1);
+    frt_is_close(is2);
+    frt_store_deref(c_reader);
+}
+
+void test_compound_writer(TestCase *tc, void *data)
+{
+    FrtStore *store = (FrtStore *)data;
+    char *p;
+    FrtOutStream *os1 = store->new_output(store, "file1");
+    FrtOutStream *os2 = store->new_output(store, "file2");
+    FrtCompoundWriter *cw;
+    FrtInStream *is;
+
+    frt_os_write_u32(os1, 20);
+    frt_os_write_string(os2,"this is file2");
+    frt_os_close(os1);
+    frt_os_close(os2);
+    cw = frt_open_cw(store, (char *)"cfile");
+    frt_cw_add_file(cw, (char *)"file1");
+    frt_cw_add_file(cw, (char *)"file2");
+    frt_cw_close(cw);
+
+    is = store->open_input(store, "cfile");
+    Aiequal(2, frt_is_read_vint(is));
+    Aiequal(29, frt_is_read_u64(is));
+    Asequal("file1", p = frt_is_read_string(is)); free(p);
+    Aiequal(33, frt_is_read_u64(is));
+    Asequal("file2", p = frt_is_read_string(is)); free(p);
+    Aiequal(20, frt_is_read_u32(is));
+    Asequal("this is file2", p = frt_is_read_string(is)); free(p);
+
+    frt_is_close(is);
+}
+
+void test_compound_io(TestCase *tc, void *data)
+{
+    FrtStore *c_reader;
+    FrtInStream *is1, *is2, *is3;
+    FrtStore *store = (FrtStore *)data;
+    FrtCompoundWriter *cw;
+    char *p;
+    FrtOutStream *os1 = store->new_output(store, "file1");
+    FrtOutStream *os2 = store->new_output(store, "file2");
+    FrtOutStream *os3 = store->new_output(store, "file3");
+    char long_string[10000];
+    const char *short_string = "this is a short string";
+    int slen = (int)strlen(short_string);
+    int i;
+
+    for (i = 0; i < 20; i++) {
+        frt_os_write_u32(os1, rand()%10000);
+    }
+
+    for (i = 0; i < 10000 - slen; i += slen) {
+        sprintf(long_string + i, "%s", short_string);
+    }
+    long_string[i] = 0;
+    frt_os_write_string(os2, long_string);
+    frt_os_write_string(os3, short_string);
+    frt_os_close(os1);
+    frt_os_close(os2);
+    frt_os_close(os3);
+    cw = frt_open_cw(store, (char *)"cfile");
+    frt_cw_add_file(cw, (char *)"file1");
+    frt_cw_add_file(cw, (char *)"file2");
+    frt_cw_add_file(cw, (char *)"file3");
+    frt_cw_close(cw);
+
+    c_reader = frt_open_cmpd_store(store, "cfile");
+    is1 = c_reader->open_input(c_reader, "file1");
+    for (i = 0; i < 20; i++) {
+        Assert(frt_is_read_u32(is1) < 10000, "should be a rand between 0 and 10000");
+    }
+    frt_is_close(is1);
+    is2 = c_reader->open_input(c_reader, "file2");
+    Asequal(long_string, p = frt_is_read_string(is2)); free(p);
+    frt_is_close(is2);
+    is3 = c_reader->open_input(c_reader, "file3");
+    Asequal(short_string, p = frt_is_read_string(is3)); free(p);
+    frt_is_close(is3);
+
+    frt_store_deref(c_reader);
+}
+
+#define MAX_TEST_WORDS 50
+#define TEST_FILE_CNT 100
+
+void test_compound_io_many_files(TestCase *tc, void *data)
+{
+    static const int MAGIC = 250777;
+
+    FrtStore *store = (FrtStore *)data;
+    char buf[MAX_TEST_WORDS * (TEST_WORD_LIST_MAX_LEN + 1)];
+    char *str;
+    int i;
+    FrtOutStream *os;
+    FrtInStream *is;
+    FrtCompoundWriter *cw;
+    FrtStore *c_reader;
+
+    cw = frt_open_cw(store, (char *)"_.cfs");
+    for (i = 0; i < TEST_FILE_CNT; i++) {
+        sprintf(buf, "_%d.txt", i);
+        frt_cw_add_file(cw, buf);
+        os = store->new_output(store, buf);
+        frt_os_write_string(os, make_random_string(buf, MAX_TEST_WORDS));
+        frt_os_write_vint(os, MAGIC);
+        frt_os_close(os);
+    }
+    frt_cw_close(cw);
+
+    c_reader = frt_open_cmpd_store(store, "_.cfs");
+    for (i = 0; i < TEST_FILE_CNT; i++) {
+        sprintf(buf, "_%d.txt", i);
+        is = c_reader->open_input(c_reader, buf);
+        str = frt_is_read_string(is);
+
+        free(str);
+        Aiequal(MAGIC, frt_is_read_vint(is));
+        Aiequal(frt_is_length(is), frt_is_pos(is));
+        frt_is_close(is);
+    }
+    frt_store_deref(c_reader);
+}
+
+TestSuite *ts_compound_io(TestSuite *suite)
+{
+    FrtStore *store = frt_open_ram_store();
+
+    suite = ADD_SUITE(suite);
+
+    tst_run_test(suite, test_compound_reader, store);
+    tst_run_test(suite, test_compound_writer, store);
+    tst_run_test(suite, test_compound_io, store);
+    tst_run_test(suite, test_compound_io_many_files, store);
+
+    frt_store_deref(store);
+
+    return suite;
+}

data/ext/isomorfeus_ferret_ext/test_document.c

@@ -0,0 +1,156 @@
+#include "frt_document.h"
+#include "test.h"
+
+void test_df_standard(TestCase *tc, void *data)
+{
+    char *s;
+    FrtDocField *df;
+    (void)data;
+
+    df = frt_df_add_data(frt_df_new(rb_intern("title")), frt_estrdup("Life of Pi"));
+    df->destroy_data = true;
+    Aiequal(1, df->size);
+    Asequal("title", rb_id2name(df->name));
+    Asequal("Life of Pi", df->data[0]);
+    Aiequal(strlen("Life of Pi"), df->lengths[0]);
+    Asequal("title: \"Life of Pi\"", s = frt_df_to_s(df));
+    Afequal(1.0, df->boost);
+    free(s);
+    frt_df_destroy(df);
+
+    df = frt_df_add_data_len(frt_df_new(rb_intern("title")), (char *)"new title", 9);
+    Aiequal(1, df->size);
+    Asequal("title", rb_id2name(df->name));
+    Asequal("new title", df->data[0]);
+    Aiequal(9, df->lengths[0]);
+    frt_df_destroy(df);
+}
+
+void test_df_multi_fields(TestCase *tc, void *data)
+{
+    int i;
+    char *s;
+    FrtDocField *df;
+    (void)data;
+
+    df = frt_df_add_data(frt_df_new(rb_intern("title")), frt_estrdup("Vernon God Little"));
+    df->destroy_data = true;
+    Aiequal(1, df->size);
+    Asequal("title", rb_id2name(df->name));
+    Asequal("Vernon God Little", df->data[0]);
+    Aiequal(strlen("Vernon God Little"), df->lengths[0]);
+
+    frt_df_add_data(df, frt_estrdup("some more data"));
+    Aiequal(2, df->size);
+    Asequal("title: [\"Vernon God Little\", \"some more data\"]",
+            s = frt_df_to_s(df));
+    free(s);
+    frt_df_add_data_len(df, frt_estrdup("and more data"), 14);
+    Aiequal(3, df->size);
+    Asequal("title", rb_id2name(df->name));
+    Asequal("Vernon God Little", df->data[0]);
+    Asequal("some more data", df->data[1]);
+    Asequal("and more data", df->data[2]);
+
+    frt_df_destroy(df);
+
+    df = frt_df_add_data(frt_df_new(rb_intern("data")), frt_estrdup("start"));
+    df->destroy_data = true;
+    Aiequal(1, df->size);
+    for (i = 0; i < 1000; i++) {
+        char buf[100];
+        sprintf(buf, "<<%d>>", i);
+        frt_df_add_data(df, frt_estrdup(buf));
+        Aiequal(i + 2, df->size);
+    }
+    frt_df_destroy(df);
+}
+
+void test_doc(TestCase *tc, void *data)
+{
+    int i;
+    FrtDocument *doc;
+    FrtDocField *df;
+    (void)data;
+
+    doc = frt_doc_new();
+    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(rb_intern("title")), (char *)"title"));
+    Aiequal(1, doc->size);
+    df = frt_df_add_data(frt_df_new(rb_intern("data")), (char *)"data1");
+    frt_df_add_data(df, (char *)"data2");
+    frt_df_add_data(df, (char *)"data3");
+    frt_df_add_data(df, (char *)"data4");
+    frt_doc_add_field(doc, df);
+    Aiequal(2, doc->size);
+    Asequal("title", rb_id2name(frt_doc_get_field(doc, rb_intern("title"))->name));
+    Aiequal(1, frt_doc_get_field(doc, rb_intern("title"))->size);
+    Asequal("title", frt_doc_get_field(doc, rb_intern("title"))->data[0]);
+    Asequal("data", rb_id2name(frt_doc_get_field(doc, rb_intern("data"))->name));
+    Aiequal(4, frt_doc_get_field(doc, rb_intern("data"))->size);
+    Asequal("data1", frt_doc_get_field(doc, rb_intern("data"))->data[0]);
+    Asequal("data2", frt_doc_get_field(doc, rb_intern("data"))->data[1]);
+    Asequal("data3", frt_doc_get_field(doc, rb_intern("data"))->data[2]);
+    Asequal("data4", frt_doc_get_field(doc, rb_intern("data"))->data[3]);
+    Afequal(1.0, doc->boost);
+   frt_doc_destroy(doc);
+
+    doc = frt_doc_new();
+    for (i = 0; i < 1000; i++) {
+        char buf[100];
+        char *bufc;
+        sprintf(buf, "<<%d>>", i);
+        bufc = frt_estrdup(buf);
+        df = frt_df_add_data(frt_df_new(rb_intern(bufc)), bufc);
+        df->destroy_data = true;
+        frt_doc_add_field(doc, df);
+        Aiequal(i + 1, doc->size);
+    }
+
+    for (i = 0; i < 1000; i++) {
+        char buf[100];
+        sprintf(buf, "<<%d>>", i);
+        Aiequal(1, frt_doc_get_field(doc, rb_intern(buf))->size);
+        Aiequal(strlen(buf), frt_doc_get_field(doc, rb_intern(buf))->lengths[0]);
+        Asequal(buf, frt_doc_get_field(doc, rb_intern(buf))->data[0]);
+    }
+   frt_doc_destroy(doc);
+}
+
+void test_double_field_exception(TestCase *tc, void *data)
+{
+    volatile bool exception_thrown = false;
+    FrtDocument *doc;
+    FrtDocField *volatile df = NULL;
+    (void)data;
+
+    doc = frt_doc_new();
+    frt_doc_add_field(doc, frt_df_add_data(frt_df_new(rb_intern("title")), (char *)"title"));
+
+    FRT_TRY
+        df = frt_df_add_data_len(frt_df_new(rb_intern("title")), (char *)"title", 5);
+        frt_doc_add_field(doc, df);
+    case FRT_EXCEPTION:
+        exception_thrown = true;
+        FRT_HANDLED();
+        break;
+    case FRT_FINALLY:
+        frt_df_destroy(df);
+        break;
+    FRT_ENDTRY
+
+    Atrue(exception_thrown);
+
+   frt_doc_destroy(doc);
+}
+
+TestSuite *ts_document(TestSuite *suite)
+{
+    suite = ADD_SUITE(suite);
+
+    tst_run_test(suite, test_df_standard, NULL);
+    tst_run_test(suite, test_df_multi_fields, NULL);
+    tst_run_test(suite, test_doc, NULL);
+    tst_run_test(suite, test_double_field_exception, NULL);
+
+    return suite;
+}

data/ext/isomorfeus_ferret_ext/test_except.c

@@ -0,0 +1,244 @@
+#include "frt_except.h"
+#include "test.h"
+#include "fio_tmpfile.h"
+
+static const char *msg1 = "Message One";
+static const char *msg2 = "Message Two";
+
+static void raise_exception()
+{
+    FRT_RAISE(FRT_EXCEPTION, "%s", msg1);
+}
+
+static void inner_try(TestCase *tc)
+{
+    volatile bool exception_handled = false;
+    volatile bool ioerror_called = false;
+
+    FRT_TRY
+        raise_exception();
+        Assert(false, "Exception should have been raised");
+        break;
+    case FRT_EXCEPTION:
+        /* This should be called */
+        Astrstr(xcontext.msg, msg1);
+        exception_handled = true;
+        FRT_HANDLED();
+        FRT_RAISE(FRT_IO_ERROR, "%s", msg2);
+        Assert(false, "Exception should have been raised");
+        break;
+    case FRT_IO_ERROR:
+        ioerror_called = true;
+        break;
+    default:
+        Assert(false, "Exception should have been known");
+        break;
+    case FRT_FINALLY:
+        Assert(exception_handled, "%s", "Exception wasn't handled");
+        Assert(ioerror_called, "IO_ERROR wasn't called");
+    FRT_ENDTRY
+}
+
+static void test_nested_except(TestCase *tc, void *data)
+{
+    volatile bool ioerror_handled = false;
+    bool finally_handled = false;
+    (void)data;
+
+    FRT_TRY
+        inner_try(tc);
+        Assert(false, "Exception should have been raised");
+        break;
+    case FRT_IO_ERROR:
+        /* This should be called */
+        Astrstr(xcontext.msg, msg2);
+        ioerror_handled = true;
+        FRT_HANDLED();
+        break;
+    case FRT_EXCEPTION:
+        /* This should be called */
+        Assert(false, "Exception should not have been raised");
+        break;
+    default:
+        Assert(false, "Exception should have been known");
+        break;
+    case FRT_FINALLY:
+        finally_handled = true;
+    FRT_ENDTRY
+    Assert(ioerror_handled, "Exception wasn't handled");
+    Assert(finally_handled, "Finally wasn't handled");
+}
+
+static void test_function_except(TestCase *tc, void *data)
+{
+    volatile bool exception_handled = false;
+    bool finally_handled = false;
+    (void)data; /* suppress warning */
+
+    FRT_TRY
+        raise_exception();
+        Assert(false, "Exception should have been raised");
+        break;
+    case FRT_EXCEPTION:
+        /* This should be called */
+        Astrstr(xcontext.msg, msg1);
+#if defined(__func__) && defined(FRT_HAS_VARARGS)
+        Astrstr("raise_exception", msg1);
+#endif
+        exception_handled = true;
+        FRT_HANDLED();
+        break;
+    default:
+        Assert(false, "Exception should have been known");
+        break;
+    case FRT_FINALLY:
+        finally_handled = true;
+    FRT_ENDTRY
+    Assert(exception_handled, "Exception wasn't handled");
+    Assert(finally_handled, "Finally wasn't handled");
+}
+
+static void test_simple_except(TestCase *tc, void *data)
+{
+    volatile bool exception_handled = false;
+    bool finally_handled = false;
+    (void)data; /* suppress warning */
+
+    FRT_TRY
+        FRT_RAISE(FRT_EXCEPTION, "error message %s %d", "string", 20);
+        Assert(false, "Exception should have been raised");
+        break;
+    case FRT_EXCEPTION:
+        /* This should be called */
+        Astrstr(xcontext.msg, "error message string 20");
+#if defined(__func__) && defined(FRT_HAS_VARARGS)
+        Astrstr(xcontext.msg, __func__);
+#endif
+#if defined(FRT_HAS_VARARGS)
+        Astrstr(xcontext.msg, __FILE__);
+#endif
+        exception_handled = true;
+        FRT_HANDLED();
+        break;
+    default:
+        Assert(false, "Exception should have been known");
+        break;
+    case FRT_FINALLY:
+        finally_handled = true;
+    FRT_ENDTRY
+    Assert(exception_handled, "Exception wasn't handled");
+    Assert(finally_handled, "Finally wasn't handled");
+}
+
+static void try_xfinally1(TestCase *tc)
+{
+    bool finally_handled = false;
+
+    FRT_TRY
+        Assert(true, "No exception raised");
+    FRT_XFINALLY
+        FRT_RAISE(EXCEPTION, "%s", msg1);
+        finally_handled = true;
+    FRT_XENDTRY
+    Assert(finally_handled, "Finally wasn't handled");
+    Atrue(finally_handled);
+}
+
+static void try_xfinally2(TestCase *tc)
+{
+    bool finally_handled = false;
+
+    FRT_TRY
+        FRT_RAISE(EXCEPTION, "%s", msg1);
+        Assert(false, "Exception should have been raised");
+    FRT_XFINALLY
+        FRT_RAISE(EXCEPTION, "%s", msg1);
+        finally_handled = true;
+    FRT_XENDTRY
+    Assert(finally_handled, "Finally wasn't handled");
+    Atrue(finally_handled);
+}
+
+static void try_xcatchall(TestCase *tc)
+{
+    bool catchall_handled = false;
+
+    FRT_TRY
+        FRT_RAISE(EXCEPTION, "%s", msg1);
+        Assert(false, "Exception should have been raised");
+    FRT_XCATCHALL
+        FRT_HANDLED();
+        FRT_RAISE(EXCEPTION, "%s", msg1);
+        catchall_handled = true;
+    FRT_XENDTRY
+    Assert(catchall_handled, "Finally wasn't handled");
+    Atrue(catchall_handled);
+}
+
+static void test_xfinally(TestCase *tc, void *data)
+{
+    volatile bool exception_handled = false;
+    bool finally_handled = false;
+    (void)data; /* suppress warning */
+
+    FRT_TRY
+        try_xfinally1(tc);
+        try_xfinally2(tc);
+        try_xcatchall(tc);
+        Assert(false, "Exception should have been raised");
+        break;
+    case FRT_EXCEPTION:
+        /* This should be called */
+        Astrstr(xcontext.msg, msg1);
+        exception_handled = true;
+        FRT_HANDLED();
+        break;
+    default:
+        Assert(false, "Exception should have been known");
+        break;
+    case FRT_FINALLY:
+        finally_handled = true;
+    FRT_ENDTRY
+    Assert(exception_handled, "Exception wasn't handled");
+    Assert(finally_handled, "Finally wasn't handled");
+}
+
+static void test_uncaught_except(TestCase *tc, void *data)
+{
+    bool old_abort_setting = frt_x_abort_on_exception;
+    FILE *old_stream_setting = frt_x_exception_stream;
+    int tfd = fio_tmpfile();
+    FILE *exception_output = fdopen(tfd, "w+");
+    (void)data, (void)tc; /* suppress warning */
+
+
+    frt_x_abort_on_exception = false;
+    frt_x_exception_stream = exception_output;
+
+    /* Unhandled exception in try block */
+    FRT_TRY
+        raise_exception();
+    FRT_ENDTRY
+    Assert(frt_x_has_aborted, "Unhandled exception in try block didn't abort");
+
+    /* Unhandled exception outside of try block */
+    frt_x_has_aborted = false;
+    FRT_RAISE(FRT_EXCEPTION, "%s:", msg1);
+    Assert(frt_x_has_aborted, "Unhandled exception didn't cause an abort");
+
+    frt_x_abort_on_exception = old_abort_setting;
+    frt_x_exception_stream = old_stream_setting;
+    fclose(exception_output);
+}
+
+TestSuite *ts_except(TestSuite *suite)
+{
+    suite = ADD_SUITE(suite);
+
+    tst_run_test(suite, test_simple_except, NULL);
+    tst_run_test(suite, test_function_except, NULL);
+    tst_run_test(suite, test_nested_except, NULL);
+    tst_run_test(suite, test_xfinally, NULL);
+    tst_run_test(suite, test_uncaught_except, NULL);
+    return suite;
+}