lsup_rdf/test/test_graph.c

#include "lsup/graph.h"
#include "test.h"
#include "assets/triples.h"

#define N_LUT 13

static int
_graph_new (LSUP_StoreType type)
{
    LSUP_Graph *gr;
    LSUP_Store *store = NULL;
    if (type == LSUP_STORE_HTABLE) {
        gr = LSUP_graph_new (NULL, NULL, NULL);
    } else {
        store = LSUP_store_new (type, NULL, 0, true);
        gr = LSUP_graph_new (store, NULL, NULL);
    }
    ASSERT (gr != NULL, "Error creating graph!");

    EXPECT_PASS (LSUP_graph_set_uri (gr, "urn:gr:1"));
    EXPECT_STR_EQ (LSUP_graph_uri (gr)->data, "urn:gr:1");

    ASSERT (
            strcmp (LSUP_graph_uri (gr)->data, "urn:gr:1") == 0,
            "Graph URI mismatch!");
    EXPECT_INT_EQ (LSUP_graph_size (gr), 0);

    // Check that setup function is idempotent with clear == false.
    const LSUP_StoreInt *sif = LSUP_store_int (type);
    if (sif->setup_fn) EXPECT_INT_EQ (
            sif->setup_fn (NULL, false), LSUP_NOACTION);

    LSUP_graph_free (gr);
    LSUP_store_free (store);

    return 0;
}


/// Test creating a graph with a namespaced URI.
static int
_graph_ns_uri (LSUP_StoreType type)
{
    const LSUP_StoreInt *sif = LSUP_store_int (type);

    const char *nsdata[][2] = {
        {"ns1", "urn:ns1#"},
        {"ns2", "urn:ns2#"},
        {"ns3", "urn:ns3#"},
        {NULL}
    };

    LSUP_Store *store = NULL;
    if (sif->features & LSUP_STORE_PERM)
        store = LSUP_store_new (type, NULL, 0, true);

    log_info("Testing NSM for graph store type: %d", type);

    LSUP_NSMap *nsm = LSUP_nsmap_new();
    for (int i = 0; nsdata[i][0]; i++)
        EXPECT_PASS (LSUP_nsmap_add (nsm, nsdata[i][0], nsdata[i][1]));

    LSUP_Graph *gr = LSUP_graph_new (store, "ns1:gr1", nsm);
    ASSERT (gr != NULL, "Error creating graph!");

    ASSERT (
            LSUP_graph_uri (gr)->type == LSUP_TERM_NS_IRIREF,
            "Namespace prefixing failed!");

    LSUP_Term *comp = LSUP_iriref_new ("urn:ns1#gr1", NULL);
    ASSERT (
            LSUP_term_equals (LSUP_graph_uri (gr), comp),
            "Namespaced graph URI is incorrect!" );
    LSUP_term_free (comp);

    LSUP_graph_free (gr);
    LSUP_nsmap_free (nsm);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_add (LSUP_StoreType type)
{
    LSUP_Triple **trp = create_triples();

    LSUP_Graph *gr;
    LSUP_Store *store;
    if (type == LSUP_STORE_HTABLE) store = NULL;
    else store = LSUP_store_new (type, NULL, 0, true);

    gr = LSUP_graph_new (store, NULL, NULL);
    ASSERT (gr != NULL, "Error creating graph!");

    size_t ct;
    LSUP_graph_add (gr, trp, &ct);

    EXPECT_INT_EQ (ct, 8);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 8);

    for (int i = 0; i < sizeof (trp); i++) {
        log_info ("checking triple #%d.", i);
        ASSERT (LSUP_graph_contains (gr, trp[i]), "Triple not in graph!");
    }

    LSUP_Triple *missing_trp = LSUP_triple_new (
            trp[1]->s, trp[6]->p, trp[4]->o);
    ASSERT (! LSUP_graph_contains (gr, missing_trp), "Triple in graph!");
    free (missing_trp);

    free_triples (trp); // gr copied data.

    // Check size again after freeing triples.
    EXPECT_INT_EQ (LSUP_graph_size (gr), 8);

    LSUP_Graph *gr2 = LSUP_graph_new (NULL, NULL, NULL);

    // Test equality against empty graph.
    ASSERT (!LSUP_graph_equals (gr, gr2), "Graphs should not be equal!");
    ASSERT (!LSUP_graph_equals (gr2, gr), "Graphs should not be equal!");

    LSUP_graph_free (gr);
    LSUP_graph_free (gr2);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_get (LSUP_StoreType type)
{
    const LSUP_StoreInt *sif = LSUP_store_int (type);
    // Skip if the store doesn't support contexts.
    if (!(sif->features & LSUP_STORE_CTX)) return 0;

    LSUP_Triple **trp = create_triples();

    LSUP_Store *store;
    if (type == LSUP_STORE_HTABLE) store = NULL;
    else store = LSUP_store_new (type, NULL, 0, true);
    LSUP_Graph
        *gr1 = LSUP_graph_new (store, NULL, NULL),
        *gr2 = LSUP_graph_new (store, NULL, NULL);

    ASSERT (gr1 != NULL, "Error creating graph!");
    ASSERT (gr2 != NULL, "Error creating graph!");


    // Add 2 groups of triples to different graphs.
    void *it1 = LSUP_graph_add_init (gr1);
    for (size_t i = 0; i < 5; i++) {
        LSUP_graph_add_iter(it1, trp[i]);
    }
    LSUP_graph_add_done (it1);

    void *it2 = LSUP_graph_add_init (gr2);
    for (size_t i = 5; i < NUM_TRP; i++) {
        LSUP_graph_add_iter(it2, trp[i]);
    }
    LSUP_graph_add_done (it2);

    free_triples (trp);

    EXPECT_INT_EQ (LSUP_graph_size (gr1), 5);
    EXPECT_INT_EQ (LSUP_graph_size (gr2), 3);

    size_t ct3, ct4;
    LSUP_Graph
        *gr3 = LSUP_graph_get (store, LSUP_graph_uri (gr1), &ct3),
        *gr4 = LSUP_graph_get (store, LSUP_graph_uri (gr2), &ct4);

    EXPECT_INT_EQ (LSUP_graph_size (gr3), LSUP_graph_size (gr1));
    EXPECT_INT_EQ (LSUP_graph_size (gr4), LSUP_graph_size (gr2));

    ASSERT (!LSUP_graph_equals (gr1, gr2), "Graphs 1 and 2 are equal!");
    ASSERT (!LSUP_graph_equals (gr3, gr4), "Graphs 3 and 4 are equal!");
    ASSERT (LSUP_graph_equals (gr1, gr3), "Graphs 1 and 3 are not equal!");
    ASSERT (LSUP_graph_equals (gr2, gr4), "Graphs 2 and 4 are not equal!");

    LSUP_graph_free (gr1);
    LSUP_graph_free (gr2);
    LSUP_graph_free (gr3);
    LSUP_graph_free (gr4);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_link_map (LSUP_StoreType type)
{
    LSUP_Triple **trp = create_triples();

    LSUP_Store *store;
    if (type == LSUP_STORE_HTABLE) store = NULL;
    else store = LSUP_store_new (type, NULL, 0, true);
    LSUP_Graph *gr = LSUP_graph_new (store, NULL, NULL);

    size_t ct;
    LSUP_graph_add (gr, trp, &ct);

    LSUP_LinkMap *lmap;
    LSUP_LinkMapIterator *lmit ;
    //LSUP_Term *k = NULL;
    LSUP_TermSet *ts = NULL;  // Term set being iterated in link map loop.
    LSUP_Term *k_res[9] = {NULL};  // Collected keys.
    LSUP_Term *ts_res[9] = {NULL};  // Collected terms in term set in loop.
    size_t i = 0, j = 0;

    /*
    LSUP_Term *po[6][4] = {
        {trp[0]->p, trp[0]->o, NULL},
        {trp[3]->p, trp[3]->o, NULL},
        {trp[4]->p, trp[4]->o, trp[7]->o, NULL},
        {trp[5]->p, trp[5]->o, NULL},
        {NULL}
    };
    */

    // terms connected to subject, urn:s:0
    lmap = LSUP_graph_connections (gr, trp[0]->s, LSUP_LINK_OUTBOUND);
    lmit = LSUP_link_map_iter_new (lmap);
    while (LSUP_link_map_next (lmit, k_res + i, &ts) == LSUP_OK) {
        while (LSUP_term_set_next (ts, &j, ts_res + j) == LSUP_OK);
        /*
        // TODO test exact terms. This requires a cross-check.
        ASSERT (
                LSUP_term_equals (k_res[i], po[i][0]),
                "Wrong term in link map!");
        for (size_t k = 1; po[i][k]; k++)
            ASSERT (
                    LSUP_term_equals (ts_res[k - 1], po[i][k]),
                    "Wrong term in term set!");
        */
        i++;
    }
    LSUP_link_map_iter_free (lmit);
    LSUP_link_map_free (lmap);
    EXPECT_INT_EQ (i, 4);

    i = 0; j = 0;
    memset (k_res, 0, sizeof (k_res));
    memset (ts_res, 0, sizeof (ts_res));
    /*
    LSUP_Term *so[3][3] = {
        {trp[1]->s, trp[1]->o, NULL},
        {trp[3]->s, trp[3]->o, NULL},
    };
    */
    // terms connected to predicate, urn:p:1
    lmap = LSUP_graph_connections (gr, trp[1]->p, LSUP_LINK_EDGE);
    lmit = LSUP_link_map_iter_new (lmap);
    while (LSUP_link_map_next (lmit, k_res + i, &ts) == LSUP_OK) {
        while (LSUP_term_set_next (ts, &j, ts_res + j) == LSUP_OK);
        /*
        ASSERT (
                LSUP_term_equals (k_res[i], so[i][0]),
                "Wrong term in link map!");
        for (size_t k = 1; so[i][k]; k++)
            ASSERT (
                    LSUP_term_equals (ts_res[k - 1], so[i][k]),
                    "Wrong term in term set!");
        */
        i++;
    }
    LSUP_link_map_iter_free (lmit);
    LSUP_link_map_free (lmap);
    EXPECT_INT_EQ (i, 2);

    i = 0; j = 0;
    memset (k_res, 0, sizeof (k_res));
    memset (ts_res, 0, sizeof (ts_res));
    /*
    LSUP_Term *sp[1][3] = {
        {trp[6]->s, trp[6]->p, NULL},
    };
    */
    // terms connected to object, "String 1"@es-ES
    lmap = LSUP_graph_connections (gr, trp[6]->o, LSUP_LINK_INBOUND);
    lmit = LSUP_link_map_iter_new (lmap);
    while (LSUP_link_map_next (lmit, k_res + i, &ts) == LSUP_OK) {
        while (LSUP_term_set_next (ts, &j, ts_res + j) == LSUP_OK);
        /*
        ASSERT (
                LSUP_term_equals (k_res[i], sp[i][0]),
                "Wrong term in link map!");
        for (size_t k = 1; sp[i][k]; k++)
            ASSERT (
                    LSUP_term_equals (ts_res[k - 1], sp[i][k]),
                    "Wrong term in term set!");
        */
        i++;
    }
    LSUP_link_map_iter_free (lmit);
    LSUP_link_map_free (lmap);
    EXPECT_INT_EQ (i, 1);

    free_triples (trp);
    LSUP_graph_free (gr);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_bool_ops (LSUP_StoreType type)
{
    const LSUP_StoreInt *sif = LSUP_store_int (type);
    // Skip if the store doesn't support contexts.
    if (!(sif->features & LSUP_STORE_CTX)) return 0;

    LSUP_Triple **trp = create_triples();

    LSUP_Store *store;
    if (type == LSUP_STORE_HTABLE) store = NULL;
    else store = LSUP_store_new (type, NULL, 0, true);
    LSUP_Graph
        *gr1 = LSUP_graph_new (store, NULL, NULL),
        *gr2 = LSUP_graph_new (store, NULL, NULL),
        *gr_dest;

    // Add 2 groups of triples to different graphs.
    void *it;

    it = LSUP_graph_add_init (gr1);
    for (size_t i = 0; i < 4; i++) {
        LSUP_graph_add_iter(it, trp[i]);
    }
    LSUP_graph_add_done (it);

    // Skip duplicate triples, we already tested those.
    // trp[3] is in both graphs.
    it = LSUP_graph_add_init (gr2);
    for (size_t i = 3; i < 8; i++) {
        LSUP_graph_add_iter(it, trp[i]);
    }
    LSUP_graph_add_done (it);

    // Test union.
    gr_dest = LSUP_graph_new (store, NULL, NULL);
    EXPECT_PASS (LSUP_graph_bool_op (LSUP_BOOL_UNION, gr1, gr2, gr_dest));
    for (size_t i = 0; i < 8; i++)
        ASSERT (LSUP_graph_contains (gr_dest, trp[i]), "Union test failed!");
    LSUP_graph_free (gr_dest);

    // Test subtraction.
    gr_dest = LSUP_graph_new (store, NULL, NULL);
    EXPECT_PASS (LSUP_graph_bool_op (
                LSUP_BOOL_SUBTRACTION, gr1, gr2, gr_dest));
    for (size_t i = 0; i < 3; i++)
        ASSERT (LSUP_graph_contains (
                    gr_dest, trp[i]), "Subtraction test is missing triples!");
    for (size_t i = 3; i < 8; i++)
        ASSERT (!LSUP_graph_contains (
                    gr_dest, trp[i]), "Subtraction test has excess triples!");
    LSUP_graph_free (gr_dest);

    gr_dest = LSUP_graph_new (store, NULL, NULL);
    EXPECT_PASS (LSUP_graph_bool_op (
                LSUP_BOOL_SUBTRACTION, gr2, gr1, gr_dest));
    for (size_t i = 0; i < 4; i++)
        ASSERT (!LSUP_graph_contains (
                    gr_dest, trp[i]), "Subtraction test is missing triples!");
    for (size_t i = 4; i < 8; i++)
        ASSERT (LSUP_graph_contains (
                    gr_dest, trp[i]), "Subtraction test has excess triples!");
    LSUP_graph_free (gr_dest);

    // Test intersection.
    gr_dest = LSUP_graph_new (store, NULL, NULL);
    EXPECT_PASS (LSUP_graph_bool_op (
                LSUP_BOOL_INTERSECTION, gr1, gr2, gr_dest));
    for (size_t i = 0; i < 3; i++)
        ASSERT (!LSUP_graph_contains (
                    gr_dest, trp[i]), "Intersection is missing triples!");
    ASSERT (LSUP_graph_contains (
            gr_dest, trp[3]), "Intersection test failed!");
    for (size_t i = 4; i < 8; i++)
        ASSERT (!LSUP_graph_contains (
                    gr_dest, trp[i]), "Intersection test has excess triples!");
    LSUP_graph_free (gr_dest);

    // Test XOR.
    gr_dest = LSUP_graph_new (store, NULL, NULL);
    EXPECT_PASS (LSUP_graph_bool_op (LSUP_BOOL_XOR, gr1, gr2, gr_dest));
    for (size_t i = 0; i < 3; i++)
        ASSERT (LSUP_graph_contains (
                    gr_dest, trp[i]), "XOR test is missing triples!");
    ASSERT (!LSUP_graph_contains (
            gr_dest, trp[3]), "XOR test has excess triples!");
    for (size_t i = 4; i < 8; i++)
        ASSERT (LSUP_graph_contains (
                    gr_dest, trp[i]), "XOR test is missing triples!");
    LSUP_graph_free (gr_dest);

    // Test union with result graph as one of the sources.
    EXPECT_PASS (LSUP_graph_bool_op (LSUP_BOOL_UNION, gr1, gr2, gr1));
    for (size_t i = 0; i < 8; i++)
        ASSERT (LSUP_graph_contains (gr1, trp[i]), "Self-union test failed!");

    LSUP_graph_free (gr1);
    LSUP_graph_free (gr2);
    free_triples (trp);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_lookup (LSUP_StoreType type)
{
    LSUP_Triple **trp = create_triples();

    // Lookup triples.
    LSUP_Term *lu_trp[N_LUT][3] = {
        {NULL, NULL, NULL},                 // 8 matches
        {trp[0]->s, NULL, NULL},            // 5 matches
        {NULL, trp[2]->p, NULL},            // 3 matches
        {NULL, NULL, trp[5]->o},            // 2 matches
        {trp[0]->s, trp[0]->p, NULL},       // 1 match
        {NULL, trp[0]->p, trp[0]->o},       // 1 match
        {trp[0]->s, trp[2]->p, trp[5]->o},  // 1 match
        {trp[0]->p, NULL, NULL},            // 0 matches
        {NULL, trp[2]->s, NULL},            // 0 matches
        {NULL, NULL, trp[5]->p},            // 0 matches
        {trp[2]->s, trp[6]->p, NULL},       // 0 matches
        {NULL, trp[1]->p, trp[5]->o},       // 0 matches
        {trp[2]->s, trp[2]->p, trp[5]->o},  // 0 matches
    };

    // Lookup result counts.
    size_t lu_ct[N_LUT] = {
        8,
        5, 3, 2,
        1, 1, 1,
        0, 0, 0,
        0, 0, 0
    };

    /* TODO
    // Index of lookup matches from trp.
    size_t lu_match[N_LUT][8] = {
        {0, 1, 2, 3, 4, 5, 6, 7},
        {0, 3, 4, 5, 7}, {2, 4, 7}, {5, 7},
        {0}, {0}, {7},
        {}, {}, {},
        {}, {}, {},
    };

    // Index of lookup non-matches from trp.
    size_t lu_no_match[N_LUT][8] = {
        {},
        {1, 2, 6}, {0, 1, 3, 5, 6}, {0, 1, 2, 3, 4, 6},
        {1, 2, 3, 4, 5, 6, 7}, {1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6},
        {0, 1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7},
        {0, 1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7}, {0, 1, 2, 3, 4, 5, 6, 7},
    };
    */

    LSUP_Graph *gr;
    LSUP_Store *store = NULL;
    if (type == LSUP_STORE_HTABLE) {
        gr = LSUP_graph_new (NULL, NULL, NULL);
    } else {
        store = LSUP_store_new (type, NULL, 0, true);
        gr = LSUP_graph_new (store, NULL, NULL);
    }

    size_t ct;
    LSUP_graph_add (gr, trp, &ct);

    EXPECT_INT_EQ (ct, 8);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 8);

    for (int i = 0; i < N_LUT; i++) {
        log_info ("Checking triple #%d on %d.", i, type);
        LSUP_GraphIterator *it = LSUP_graph_lookup (
                gr, lu_trp[i][0], lu_trp[i][1], lu_trp[i][2], &ct);
        EXPECT_INT_EQ (ct, lu_ct[i]);

        // Verify that iteration count matches stat count.
        LSUP_Triple *spo = NULL;
        ct = 0;
        while (LSUP_graph_iter_next (it, &spo) != LSUP_END) {
            ct++;
            // TODO do something useful with the triple.
            LSUP_triple_free (spo);
            spo = NULL;
        }
        LSUP_triple_free (spo);
        EXPECT_INT_EQ (ct, lu_ct[i]);

        /* TODO
        for (int j = 0; j < 8; j++) {
            for (int k = 0; LSUP_graph_iter_next(it) != LSUP_END; k++) {
                ASSERT (
                        LSUP_graph_contains (trp[lu_match[j]]),
                        "Triple not found!");
                ASSERT (
                        !(LSUP_graph_contains (trp[lu_no_match[j]])),
                        "Unexpected triple found!");
            }
        }
        */

        LSUP_graph_iter_free (it);
    };

#if 0
    // Enable to test print functionality and exit early.
    LSUP_graph_print (gr);
    return 1;
#endif

    free_triples (trp);
    LSUP_graph_free (gr);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_remove (LSUP_StoreType type)
{
    LSUP_Triple **trp = create_triples();

    LSUP_Graph *gr;
    LSUP_Store *store = NULL;
    if (type == LSUP_STORE_HTABLE) {
        gr = LSUP_graph_new (NULL, NULL, NULL);
    } else {
        store = LSUP_store_new (type, NULL, 0, true);
        gr = LSUP_graph_new (store, NULL, NULL);
    }

    size_t ct;
    LSUP_graph_add (gr, trp, &ct);

    EXPECT_INT_EQ (ct, 8);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 8);

    // Triples 0, 3, 4, 5, 7 will be removed.
    LSUP_graph_remove (gr, trp[0]->s, NULL, NULL, &ct);
    EXPECT_INT_EQ (ct, 5);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 3);

    ASSERT (!LSUP_graph_contains (gr, trp[0]), "Unexpected triple found!");
    ASSERT (LSUP_graph_contains (gr, trp[1]), "Triple not in graph!");
    ASSERT (LSUP_graph_contains (gr, trp[2]), "Triple not in graph!");
    ASSERT (!LSUP_graph_contains (gr, trp[3]), "Unexpected triple found!");
    ASSERT (!LSUP_graph_contains (gr, trp[4]), "Unexpected triple found!");
    ASSERT (!LSUP_graph_contains (gr, trp[5]), "Unexpected triple found!");
    ASSERT (LSUP_graph_contains (gr, trp[6]), "Triple not in graph!");
    ASSERT (!LSUP_graph_contains (gr, trp[7]), "Unexpected triple found!");

    free_triples (trp); // gr copied data.

    LSUP_graph_free (gr);
    LSUP_store_free (store);

    // TODO Test complete removal of triples from index when they are not
    // in another context.

    return 0;
}


static int
_graph_txn (LSUP_StoreType type)
{
    const LSUP_StoreInt *sif = LSUP_store_int (type);
    if (!(sif->features & LSUP_STORE_TXN)) return 0;

    LSUP_Triple **trp = create_triples();

    LSUP_Graph *gr;
    LSUP_Store *store =
        type == LSUP_STORE_HTABLE ? NULL
        : LSUP_store_new (type, NULL, 0, true);

    gr = LSUP_graph_new (store, NULL, NULL);

    void *txn;
    size_t ct;

    EXPECT_PASS (LSUP_store_begin (store, 0, &txn));
    EXPECT_PASS (LSUP_graph_add_txn (txn, gr, trp, &ct));
    LSUP_store_abort (store, txn);

    // NOTE that ct reports the count before the txn was aborted. This is
    // intentional.
    EXPECT_INT_EQ (ct, 8);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 0);

    EXPECT_PASS (LSUP_store_begin (store, 0, &txn));
    EXPECT_PASS (LSUP_graph_add_txn (txn, gr, trp, &ct));
    LSUP_store_commit (store, txn);

    EXPECT_INT_EQ (ct, 8);
    EXPECT_INT_EQ (LSUP_graph_size (gr), 8);

    LSUP_graph_free (gr);
    LSUP_store_free (store);

    free_triples (trp); // gr copied data.

    return 0;
}


static int
_graph_relative (LSUP_StoreType type)
{
    LSUP_Term
        *s = LSUP_iriref_new ("http://onto.knowledgetx.com/gr1/s1", NULL),
        *s2 = LSUP_iriref_new ("http://onto.knowledgetx.com/gr2/s1", NULL),
        *p = LSUP_iriref_new ("http://onto.knowledgetx.com/vocab/p1", NULL),
        *o = LSUP_iriref_new ("http://onto.knowledgetx.com/gr1/o1", NULL),
        *o2 = LSUP_iriref_new ("http://onto.knowledgetx.com/gr2/o1", NULL),
        *c = LSUP_iriref_new ("http://onto.knowledgetx.com/gr1/", NULL),
        *rel_s = LSUP_iriref_relative (c, s),
        *rel_o = LSUP_iriref_relative (c, o);
    LSUP_Triple *spo[2] = {
        LSUP_triple_new (s, p, o),
        NULL
    };
    LSUP_Triple *rel_spo = LSUP_triple_new (rel_s, p, rel_o);

    LSUP_Store *store =
        type == LSUP_STORE_HTABLE ? NULL
        : LSUP_store_new (type, NULL, 0, true);

    LSUP_Graph *gr = LSUP_graph_new (store, c->data, NULL);

    size_t ct;
    LSUP_graph_add (gr, spo, &ct);

    // Both absolute and relative IRIs should be found.
    ASSERT (LSUP_graph_contains (gr, rel_spo), "Relative triple not found!");
    ASSERT (LSUP_graph_contains (gr, spo[0]), "Absolute triple not found!");

    // Change graph URI and verify that relative URIs are still found, and
    // that absolute URIs change with it.
    spo[0]->s = s2;
    LSUP_term_free (s);
    spo[0]->o = o2;
    LSUP_term_free (o);

    LSUP_graph_set_uri (gr, "http://onto.knowledgetx.com/gr2/");
    LSUP_term_free (c);

    ASSERT (LSUP_graph_contains (gr, rel_spo), "Relative triple not found!");
    ASSERT (LSUP_graph_contains (gr, spo[0]), "Absolute triple not found!");

    LSUP_triple_free (spo[0]);
    LSUP_term_free (rel_s);
    LSUP_term_free (rel_o);
    free (rel_spo);
    LSUP_graph_free (gr);
    LSUP_store_free (store);

    return 0;
}


static int
_graph_list (LSUP_StoreType type)
{
    const LSUP_StoreInt *sif = LSUP_store_int (type);
    if (!(sif->features & LSUP_STORE_CTX)) return 0;

    LSUP_Store *store = LSUP_store_new (type, NULL, 0, true);

    LSUP_Graph *gg[3] = {
        LSUP_graph_new (store,  "urn:gr:1", NULL),
        LSUP_graph_new (store,  "urn:gr:2", NULL),
        LSUP_graph_new (store,  "urn:gr:3", NULL),
    };

    LSUP_Triple **trp = create_triples();
    LSUP_graph_add (gg[0], trp, NULL);  // Add some triples to the 1st graph.
    LSUP_graph_add (gg[1], trp + 4, NULL);  // Same with the 2nd graph.
    free_triples (trp);

    LSUP_TermSet *ts = LSUP_graph_list (store);
    ASSERT (ts != NULL, "Error creating context list!");

    EXPECT_INT_EQ (hashmap_count (ts), 2);

    // Check if first 2 graphs (with triples) are in the context set.
    LSUP_Hash key;
    key = LSUP_term_hash (LSUP_graph_uri (gg[0]));
    ASSERT (LSUP_term_set_get (ts, key) != NULL, "Context  #1 not found!");
    key = LSUP_term_hash (LSUP_graph_uri (gg[1]));
    ASSERT (LSUP_term_set_get (ts, key) != NULL, "Context #2 not found!");
    key = LSUP_term_hash (LSUP_graph_uri (gg[2]));
    ASSERT (
            LSUP_term_set_get (ts, key) == NULL,
            "Empty context shoud not be here!");

    for (size_t i = 0; i < 3; i++) LSUP_graph_free (gg[i]);
    LSUP_term_set_free (ts);
    LSUP_store_free (store);

    return 0;
}


static int
test_environment()
{
    // The env should already be initialized and re-initializing it is idempotent.
    EXPECT_INT_EQ (LSUP_IS_INIT, true);
    ASSERT (LSUP_init() > 0, "Error initializing environment!");
    EXPECT_INT_EQ (LSUP_IS_INIT, true);

    // Tearing down is idempotent too.
    LSUP_done();
    EXPECT_INT_EQ (LSUP_IS_INIT, false);
    LSUP_done();
    EXPECT_INT_EQ (LSUP_IS_INIT, false);

    ASSERT (LSUP_init() >= 0, "Environment not initialized!");
    EXPECT_INT_EQ (LSUP_IS_INIT, true);
    ASSERT (LSUP_init() >= 0, "Environment not initialized!");
    EXPECT_INT_EQ (LSUP_IS_INIT, true);

    return 0;
}


static int test_graph_new() {
#define ENTRY(a, b) \
    if (_graph_new (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_ns_uri() {
#define ENTRY(a, b) \
    if (_graph_ns_uri (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_add() {
#define ENTRY(a, b) \
    if (_graph_add (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_get() {
#define ENTRY(a, b) \
    if (_graph_get (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_link_map() {
#define ENTRY(a, b) \
    if (_graph_link_map (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_bool_ops() {
#define ENTRY(a, b) \
    if (_graph_bool_ops (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_lookup() {
#define ENTRY(a, b) \
    if (_graph_lookup (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_remove() {
#define ENTRY(a, b) \
    if (_graph_remove (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_txn()
{
    /*
     * Test transactions only if the backend supports them.
     */
#define ENTRY(a, b) \
    if (_graph_txn (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_relative()
{
    /*
     * Test relative URIs in graphs.
     */
#define ENTRY(a, b) \
    if (_graph_relative (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_list()
{
    /*
     * Test relative URIs in graphs.
     */
#define ENTRY(a, b) \
    if (_graph_list (LSUP_STORE_##a) != 0) return -1;
BACKEND_TBL
#undef ENTRY

    return 0;
}


static int test_graph_copy()
{
    LSUP_Triple **trp = create_triples();

    LSUP_Graph *gr1 = LSUP_graph_new (NULL, NULL, NULL);
    ASSERT (gr1 != NULL, "Error creating graph!");

    LSUP_graph_add (gr1, trp, NULL);

    // Copy to graph with same store type.
    LSUP_Graph *gr2 = LSUP_graph_new (NULL, NULL, NULL);
    EXPECT_PASS (LSUP_graph_copy_contents (gr1, gr2, NULL, NULL, NULL));
    EXPECT_INT_EQ (LSUP_graph_size (gr1), LSUP_graph_size (gr2));

    for (int i = 0; i < sizeof (trp); i++) {
        log_info ("checking triple #%d.", i);
        ASSERT (
                LSUP_graph_contains (gr2, trp[i]),
                "Triple not in copied graph!");
    }

    // Copy to graph with a different store type.
    LSUP_Graph *gr3 = LSUP_graph_new (NULL, NULL, NULL);
    EXPECT_PASS (LSUP_graph_copy_contents (gr1, gr3, NULL, NULL, NULL));
    EXPECT_INT_EQ (LSUP_graph_size (gr1), LSUP_graph_size (gr2));

    for (int i = 0; i < sizeof (trp); i++) {
        log_info ("checking triple #%d.", i);
        ASSERT (
                LSUP_graph_contains (gr3, trp[i]),
                "Triple not in copied graph!");
    }

    LSUP_graph_free (gr3);
    LSUP_graph_free (gr2);
    LSUP_graph_free (gr1);
    free_triples (trp);

    return 0;
}


int graph_tests()
{
    RUN (test_environment);
    RUN (test_graph_new);
    RUN (test_graph_ns_uri);
    RUN (test_graph_add);
    RUN (test_graph_get);
    RUN (test_graph_link_map);
    RUN (test_graph_bool_ops);
    RUN (test_graph_lookup);
    RUN (test_graph_remove);
    RUN (test_graph_copy);
    RUN (test_graph_txn);
    RUN (test_graph_relative);
    RUN (test_graph_list);

    return 0;
}