lsup_rdf/test/test_codec_nt.c

#include "test.h"
#include "codec_nt.h"

#define TERM_CT 10

typedef char nt_str[64];

static LSUP_Term **
init_terms (void)
{
    LSUP_Term **terms = malloc (TERM_CT * sizeof (*terms));
    terms[0] = LSUP_uri_new ("urn:local:s1");
    terms[1] = LSUP_uri_new ("http://example.org/p1");
    terms[2] = LSUP_term_new (LSUP_TERM_LITERAL, "hello", NULL, NULL);
    terms[3] = LSUP_term_new (LSUP_TERM_LITERAL, "hello", NULL, "en-US");
    terms[4] = LSUP_term_new (
            LSUP_TERM_LITERAL, "hello", DEFAULT_DTYPE, "es-ES");
    terms[5] = LSUP_term_new (
            LSUP_TERM_LITERAL, "25",
            "http://www.w3.org/2001/XMLSchema#integer", NULL);
    terms[6] = LSUP_term_new (
            LSUP_TERM_LITERAL, "This \\is\\ a \"multi-line\"\n'literal'\t.",
            NULL, NULL);
    terms[7] = LSUP_term_new (LSUP_TERM_BNODE, "bn1", NULL, NULL);
    terms[8] = LSUP_term_new (LSUP_TERM_UNDEFINED, "bogus", NULL, NULL);
    terms[9] = 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> ",
    "\"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>",
    "\"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.
static char *start_doc = (
    "<urn:local:s1> <http://example.org/p1> \"hello\" . #  Comment here.\n"
    "<urn:local:s1> <http://example.org/p1>\"hello\"@es-ES .\n"
    "# Some comments\n# To make it a bit \n   #less boring.\n"
    "<urn:local:s1> <http://example.org/p1> _: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"
);


static char *bad_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> dc:title \"Bad Data.\" ."
);


// End result NT document as it should be produced by the NT codec.
// Lines should not be checked in strict order.
static char *end_doc[6] = {
    "<urn:local:s1> <http://example.org/p1> \"hello\" .\n",
    "<urn:local:s1> <http://example.org/p1> \"hello\"@es-ES .\n",
    "<urn:local:s1> <http://example.org/p1> _: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 LSUP_Triple trp[8];

static void
init_triples(LSUP_Term **terms)
{
    memset (trp, 0, sizeof (LSUP_Triple) * 8); // Last NULL is a sentinel

    LSUP_triple_init (trp + 0, terms[0], terms[1], terms[2]);
    LSUP_triple_init (trp + 1, terms[0], terms[1], terms[3]);
    LSUP_triple_init (trp + 2, terms[0], terms[1], terms[4]);
    LSUP_triple_init (trp + 3, terms[0], terms[1], terms[7]);
    LSUP_triple_init (trp + 4, terms[7], terms[1], terms[4]);
    LSUP_triple_init (trp + 5, terms[7], terms[1], terms[5]);
    LSUP_triple_init (trp + 6, terms[7], terms[1], terms[6]);
}


static void
free_terms (LSUP_Term **terms)
{
    for (int i = 0; i < TERM_CT; i++)
        LSUP_term_free (terms[i]);

    free (terms);
}


static int
test_encode_nt_term()
{
    LSUP_Term **terms = init_terms();

    LSUP_NSMap *nsm = LSUP_nsmap_new();
    LSUP_nsmap_add (nsm, "local", "urn:local:");
    LSUP_nsmap_add (nsm, "ext", "http://example.org");

    char *out = NULL;

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

    for (int i = 0; i < TERM_CT - 2; i++) {
        EXPECT_PASS (nt_codec.encode_term (terms[i], NULL, &out));
        EXPECT_STR_EQ (out, end_nt[i]);
    }

    EXPECT_INT_EQ (nt_codec.encode_term (terms[8], NULL, &out), LSUP_VALUE_ERR);
    ASSERT (out == NULL, "Encoding of undefined term should be NULL!");

    EXPECT_INT_EQ (nt_codec.encode_term (terms[9], NULL, &out), LSUP_VALUE_ERR);
    ASSERT (out == NULL, "Encoding of undefined term should be NULL!");

    free (out);
    LSUP_nsmap_free (nsm);
    free_terms(terms);

    return 0;
}


static int test_encode_nt_graph()
{
    LSUP_Graph *gr = LSUP_graph_new (LSUP_STORE_MEM);
    if (!gr) return LSUP_MEM_ERR;

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

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

    char *tmp;
    LSUP_rc rc;
    while ((rc = nt_codec.encode_graph_iter (it, (unsigned char **)&tmp)) != LSUP_END) {
        ASSERT (rc >= 0, "Encoding step failed!");
        out = realloc (out, strlen(out) + strlen (tmp) + 1);
        out = strcat (out, tmp);
    }
    nt_codec.encode_graph_done (it);
    free (tmp);
    LSUP_graph_free (gr);
    //printf("Serialized graph: %s\n", out);

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

    free (out);

    return 0;
}


static int
test_decode_nt_term()
{
    for (int i = 0; i < TERM_CT - 2; i++) {
        LSUP_Term *term;
        EXPECT_PASS (nt_codec.decode_term (start_nt[i], NULL, &term));
        LSUP_term_free (term);
    }

    return 0;
}


static int
test_decode_nt_graph()
{
    FILE *input = fmemopen ((void *)start_doc, strlen (start_doc), "r");

    LSUP_Graph *gr;
    size_t ct;
    char *err;
    EXPECT_PASS (nt_codec.decode_graph (input, &gr, &ct, &err));

    fclose (input);

    ASSERT (err == NULL, "Error string is not NULL!");
    EXPECT_INT_EQ (ct, 6);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 6);

    for (int i = 0; i < 7; i++)
        EXPECT_INT_EQ (LSUP_graph_contains (gr, trp + i), 1);

    LSUP_graph_free (gr);

    return 0;
}


static int
test_decode_nt_bad_graph()
{
    FILE *input = fmemopen ((void *)bad_doc, strlen (start_doc), "r");

    LSUP_Graph *gr;
    size_t ct;
    char *err;
    EXPECT_INT_EQ (nt_codec.decode_graph (input, &gr, &ct, &err), LSUP_VALUE_ERR);

    TRACE ("Error: %s", err);
    ASSERT (strstr (err, "`dc:title") != 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);
    fclose (input);
    LSUP_graph_free (gr);

    return 0;
}


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

    RUN (test_encode_nt_term);
    RUN (test_encode_nt_graph);
    RUN (test_decode_nt_term);
    RUN (test_decode_nt_graph);
    RUN (test_decode_nt_bad_graph);

    free_terms(terms);

    return 0;
}