volksdata/test/test_codec_nt.c

#include <unistd.h>

#include "volksdata/codec/codec_nt.h"
#include "test.h"

#define TERM_CT 11
#define TRP_CT 8

typedef char nt_str[64];


VOLK_Term **
init_terms (void)
{
    VOLK_Term **terms = malloc (TERM_CT * sizeof (*terms));
    terms[0] = VOLK_iriref_new("urn:local:s1");
    terms[1] = VOLK_iriref_new("http://example.org/p1");
    terms[2] = VOLK_iriref_new("http://example.org/p2");
    terms[3] = VOLK_literal_new ("hello", NULL);
    terms[4] = VOLK_lt_literal_new ("hello", "en-US");
    terms[5] = VOLK_lt_literal_new ("hello", "es-ES");
    terms[6] = VOLK_literal_new (
            "25",
            VOLK_iriref_new ("http://www.w3.org/2001/XMLSchema#integer"));
    terms[7] = VOLK_literal_new (
            "This \\is\\ a \"multi-line\"\n'literal'\t.", NULL);
    terms[8] = VOLK_bnode_new ("bn1");
    terms[9] = VOLK_term_new (VOLK_TERM_UNDEFINED, "bogus", NULL);
    terms[10] = TERM_DUMMY;

    return terms;
}

// Starting NT term strings. They may have comments and junk whitespace.
static nt_str start_nt[TERM_CT] = {
    "<urn:local:s1>",
    "<http://example.org/p1> ",
    "<http://example.org/p2> ",
    "\"hello\"^^<http://www.w3.org/2001/XMLSchema#string>",
    "\"hello\" @en-US",
    "\"hello\"@es-ES   # Does \"Hello\" in Spanish mean \"hola\"?",
    "\"25\"   ^^<http://www.w3.org/2001/XMLSchema#integer>  ",
    "\"This \\\\is\\\\ a \\\"multi-line\\\"\\n\\'literal\\'\\t.\"",
    "_:bn1",
    "This is nothing.",
    "",
};

// End result NT term strings, as they should be produced by the NT codec.
static nt_str end_nt[TERM_CT] = {
    "<urn:local:s1>",
    "<http://example.org/p1>",
    "<http://example.org/p2>",
    "\"hello\"",
    "\"hello\"@en-US",
    "\"hello\"@es-ES",
    "\"25\"^^<http://www.w3.org/2001/XMLSchema#integer>",
    "\"This \\\\is\\\\ a \\\"multi-line\\\"\\n\\'literal\\'\\t.\"",
    "_:bn1",
    "",
    "",
};

// Start NT document. It may have comments and junk whitespace.
char *start_nt_doc = (
    "<urn:local:s1> <http://example.org/p1> \"hello\" . #  Comment here.\n"
    "<urn:local:s1> <http://example.org/p1> "
        "\"hello\"^^<http://www.w3.org/2001/XMLSchema#string> .\n"
    "<urn:local:s1> <http://example.org/p2>\"hello\"@en-US.\n"
    "<urn:local:s1> <http://example.org/p2>\"hello\"@es-ES .\n"
    "# Some comments\n# To make it a bit \n   #less boring.\n"
    "<urn:local:s1> <http://example.org/p2> _:bn1 .\n"
    "_:bn1 <http://example.org/p1> \"hello\"@es-ES.\n"
    "  _:bn1 <http://example.org/p1> "
        "\"25\"^^<http://www.w3.org/2001/XMLSchema#integer> .\n"
    "_:bn1 <http://example.org/p1> "
        "\"This \\\\is\\\\ a \\\"multi-line\\\"\\n\\\'literal\\\'\\t.\""
        " .\n"
    "# FREE WHITESPACE!\n\n\n\n\n\n\n      \n\n\n\n"
);


char *bad_nt_doc = (
    "<urn:local:s1> <http://example.org/p1> \"hello\" . #  Comment here.\n"
    "<urn:local:s1> <http://example.org/p1>\"hello\"@es-ES .\n"
    "<urn:local:s1> @ \"Bad Data.\" ."
);


// End result NT document as it should be produced by the NT codec.
// Lines should not be checked in strict order.
char *end_nt_doc[7] = {
    "<urn:local:s1> <http://example.org/p1> \"hello\" .\n",
    "<urn:local:s1> <http://example.org/p2> \"hello\"@en-US .\n",
    "<urn:local:s1> <http://example.org/p2> \"hello\"@es-ES .\n",
    "<urn:local:s1> <http://example.org/p2> _:bn1 .\n",
    "_:bn1 <http://example.org/p1> \"hello\"@es-ES .\n",
    "_:bn1 <http://example.org/p1> "
        "\"25\"^^<http://www.w3.org/2001/XMLSchema#integer> .\n",
    "_:bn1 <http://example.org/p1> "
        "\"This \\\\is\\\\ a \\\"multi-line\\\"\\n\\\'literal\\\'\\t.\" .\n",
};


static VOLK_Triple *trp[TRP_CT];


void
init_triples (VOLK_Term **terms)
{
    trp[0] = VOLK_triple_new (terms[0], terms[1], terms[3]);
    trp[1] = VOLK_triple_new (terms[0], terms[2], terms[4]);
    trp[2] = VOLK_triple_new (terms[0], terms[2], terms[5]);
    trp[3] = VOLK_triple_new (terms[0], terms[2], terms[8]);
    trp[4] = VOLK_triple_new (terms[8], terms[1], terms[5]);
    trp[5] = VOLK_triple_new (terms[8], terms[1], terms[6]);
    trp[6] = VOLK_triple_new (terms[8], terms[1], terms[7]);
    trp[7] = NULL;
}


void
free_terms (VOLK_Term **terms)
{
    for (int i = 0; i < TERM_CT; i++)
        VOLK_term_free (terms[i]);
    free (terms);
}


int
test_encode_nt_term()
{
    VOLK_Term **terms = init_terms();

    VOLK_nsmap_add ("local", "urn:local:");
    VOLK_nsmap_add ("ext", "http://example.org");

    char *out = NULL;

    // Test that passing a NS map has no effect.
    EXPECT_PASS (codec.encode_term (terms[0], &out));
    EXPECT_STR_EQ (out, end_nt[0]);

    for (int i = 0; i < TERM_CT - 2; i++) {
        log_info ("Test encoding term #%d of %d.", i, TERM_CT - 2);
        EXPECT_PASS (codec.encode_term (terms[i], &out));
        EXPECT_STR_EQ (out, end_nt[i]);
    }

    EXPECT_INT_EQ (codec.encode_term (terms[9], &out), VOLK_PARSE_ERR);

    EXPECT_INT_EQ (codec.encode_term (terms[10], &out), VOLK_PARSE_ERR);

    free (out);
    free_terms (terms);

    return 0;
}


int
test_encode_nt_graph()
{
    log_info ("Test encoding graph document.");
    VOLK_Graph *gr = VOLK_graph_new (NULL, NULL);
    if (!gr) return VOLK_MEM_ERR;

    size_t ins;
    VOLK_graph_add (gr, trp, &ins);

    char *out = calloc (1, 1);
    void *it = codec.encode_graph_init (gr);
    ASSERT (it != NULL, "Error creating codec iterator!");

    char *tmp = NULL;
    VOLK_rc rc;
    while ((rc = codec.encode_graph_iter (it, &tmp)) != VOLK_END) {
        ASSERT (rc >= 0, "Encoding step failed!");
        out = realloc (out, strlen(out) + strlen (tmp) + 1);
        out = strcat (out, tmp);
    }
    codec.encode_graph_done (it);
    free (tmp);
    VOLK_graph_free (gr);
    //log_info ("Serialized graph: %s\n", out);

    for (int i = 0; i < 7; i++)
        ASSERT (strstr (out, end_nt_doc[i]) != NULL, end_nt_doc[i]);

    free (out);

    return 0;
}


static int
test_decode_nt_term()
{
    log_info ("Test decoding terms.");
    for (int i = 0; i < TERM_CT - 2; i++) {
        LOG_DEBUG("Decoding term %d/%d.", i, TERM_CT - 3);
        VOLK_Term *term;
        EXPECT_PASS (codec.decode_term (start_nt[i], &term));
        VOLK_term_free (term);
    }

    return 0;
}


int
test_decode_nt_graph()
{

    VOLK_Graph *gr;
    size_t ct;
    char *err;
    EXPECT_PASS (codec.decode_graph (NULL, start_nt_doc, &gr, &ct, &err));

    ASSERT (err == NULL, "Error string is not NULL!");

#if 1
    // For debugging: dump the decoded graph into NT.
    char *out = calloc (1, 1);
    char *tmp = NULL;
    void *it = codec.encode_graph_init (gr);
    while (codec.encode_graph_iter (it, &tmp) != VOLK_END) {
        out = realloc (out, strlen(out) + strlen (tmp) + 1);
        out = strcat (out, tmp);
    }
    codec.encode_graph_done (it);
    free (tmp);
    LOG_TRACE("Serialized graph: \n%s", out);
    free (out);

#endif
    EXPECT_INT_EQ (ct, 8);
    EXPECT_INT_EQ (VOLK_graph_size (gr), 7);

    for (int i = 0; i < 7; i++) {
        log_info ("Checking triple #%d.", i);
        EXPECT_INT_EQ (VOLK_graph_contains (gr, trp[i]), 1);
    }

    VOLK_graph_free (gr);

    return 0;
}


int
test_decode_nt_file()
{
    VOLK_Graph *gr;
    size_t ct;
    char *err;
    FILE *fh = fopen ("test/assets/test2.nt", "r");

    EXPECT_PASS (codec.decode_graph (fh, NULL, &gr, &ct, &err));

    EXPECT_INT_EQ (VOLK_graph_size (gr), 7);
    EXPECT_INT_EQ (ct, 8);

    VOLK_graph_free (gr);
    fclose(fh);

    return 0;
}


#define LARGE_LIT_SIZE CHUNK_SIZE * 2 + 1  // More than 2  buffer pages.
int
test_decode_large_lit_file()
{
    VOLK_Graph *gr;
    size_t ct;
    char *err;
    const char *fpath = "/tmp/test_large_lit.nt";
    FILE *fh = fopen (fpath, "w");

    fprintf (fh, "<urn:s:1> <urn:p:1> \"");
    for (unsigned i = 0; i < LARGE_LIT_SIZE; i++)
        fputc (rand() % 25 + 65, fh);  // A-Z
    fprintf(fh, "\" .\n");
    fclose(fh);

    fh = fopen (fpath, "r");
    EXPECT_PASS (codec.decode_graph (fh, NULL, &gr, &ct, &err));

    EXPECT_INT_EQ (VOLK_graph_size (gr), 1);
    EXPECT_INT_EQ (ct, 1);

    VOLK_graph_free (gr);
    fclose(fh);
    unlink (fpath);

    return 0;
}


int
test_decode_nt_bad_graph()
{
    log_info ("testing illegal NT document.");

    VOLK_Graph *gr;
    size_t ct;
    char *err;
    VOLK_rc rc = codec.decode_graph (NULL, bad_nt_doc, &gr, &ct, &err);
    EXPECT_INT_EQ (rc, VOLK_PARSE_ERR);

    log_info ("Error: %s", err);
    ASSERT (strstr (err, "`@ \"Bad Data.\"") != NULL, "Wrong error string report!");
    ASSERT (strstr (err, "line 3") != NULL, "Wrong error line report!");
    ASSERT (strstr (err, "character 16") != NULL, "Wrong error char report!");

    free (err);
    VOLK_graph_free (gr);

    return 0;
}


int codec_nt_tests()
{
    VOLK_Term **terms = init_terms();
    init_triples (terms);

    codec = nt_codec;

    RUN (test_encode_nt_term);
    RUN (test_encode_nt_graph);
    RUN (test_decode_nt_term);
    RUN (test_decode_nt_graph);
    RUN (test_decode_nt_file);
    //RUN (test_decode_large_lit_file);  // FIXME large literals still not working.
    RUN (test_decode_nt_bad_graph);

    free_terms (terms);
    for (int i = 0; i < TRP_CT; i++)
        free (trp[i]);

    return 0;
}