aboutsummaryrefslogtreecommitdiffstats
path: root/test/test_node.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/test_node.c')
-rw-r--r--test/test_node.c238
1 files changed, 133 insertions, 105 deletions
diff --git a/test/test_node.c b/test/test_node.c
index 41ee6209..5c053294 100644
--- a/test/test_node.c
+++ b/test/test_node.c
@@ -59,23 +59,23 @@
static void
test_boolean(void)
{
- SerdNode* const true_node = serd_new_boolean(true);
+ SerdNode* const true_node = serd_new_boolean(NULL, true);
assert(!strcmp(serd_node_string(true_node), "true"));
assert(serd_get_boolean(true_node));
const SerdNode* const true_datatype = serd_node_datatype(true_node);
assert(true_datatype);
assert(!strcmp(serd_node_string(true_datatype), NS_XSD "boolean"));
- serd_node_free(true_node);
+ serd_node_free(NULL, true_node);
- SerdNode* const false_node = serd_new_boolean(false);
+ SerdNode* const false_node = serd_new_boolean(NULL, false);
assert(!strcmp(serd_node_string(false_node), "false"));
assert(!serd_get_boolean(false_node));
const SerdNode* const false_datatype = serd_node_datatype(false_node);
assert(false_datatype);
assert(!strcmp(serd_node_string(false_datatype), NS_XSD "boolean"));
- serd_node_free(false_node);
+ serd_node_free(NULL, false_node);
}
static void
@@ -84,12 +84,12 @@ check_get_boolean(const char* string,
const bool expected)
{
SerdNode* const node = serd_new_literal(
- SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
+ NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
assert(node);
assert(serd_get_boolean(node) == expected);
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
static void
@@ -123,7 +123,7 @@ test_decimal(void)
"0.0000000001"};
for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
- SerdNode* node = serd_new_decimal(test_values[i]);
+ SerdNode* node = serd_new_decimal(NULL, test_values[i]);
const char* node_str = serd_node_string(node);
assert(!strcmp(node_str, test_strings[i]));
@@ -136,7 +136,7 @@ test_decimal(void)
const double value = serd_get_double(node);
assert(!memcmp(&value, &test_values[i], sizeof(value)));
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
}
@@ -148,7 +148,7 @@ test_double(void)
"0.0E0", "-0.0E0", "1.2E0", "-2.3E0", "4.56789E6"};
for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
- SerdNode* node = serd_new_double(test_values[i]);
+ SerdNode* node = serd_new_double(NULL, test_values[i]);
const char* node_str = serd_node_string(node);
assert(!strcmp(node_str, test_strings[i]));
@@ -161,7 +161,7 @@ test_double(void)
const double value = serd_get_double(node);
assert(!memcmp(&value, &test_values[i], sizeof(value)));
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
}
@@ -171,14 +171,14 @@ check_get_double(const char* string,
const double expected)
{
SerdNode* const node = serd_new_literal(
- SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
+ NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
assert(node);
const double value = serd_get_double(node);
assert(!memcmp(&value, &expected, sizeof(value)));
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
static void
@@ -195,21 +195,23 @@ test_get_double(void)
SERD_DISABLE_CONVERSION_WARNINGS
- SerdNode* const nan = serd_new_string(SERD_STRING("unknown"));
+ SerdNode* const nan = serd_new_string(NULL, SERD_STRING("unknown"));
assert(isnan(serd_get_double(nan)));
- serd_node_free(nan);
+ serd_node_free(NULL, nan);
- SerdNode* const invalid = serd_new_literal(
- SERD_STRING("!invalid"), SERD_HAS_DATATYPE, SERD_STRING(NS_XSD "long"));
+ SerdNode* const invalid = serd_new_literal(NULL,
+ SERD_STRING("!invalid"),
+ SERD_HAS_DATATYPE,
+ SERD_STRING(NS_XSD "long"));
assert(isnan(serd_get_double(invalid)));
- serd_node_free(invalid);
+ serd_node_free(NULL, invalid);
SerdNode* const base64 =
- serd_new_base64(blob, sizeof(blob), SERD_EMPTY_STRING());
+ serd_new_base64(NULL, blob, sizeof(blob), SERD_EMPTY_STRING());
assert(isnan(serd_get_double(base64)));
- serd_node_free(base64);
+ serd_node_free(NULL, base64);
SERD_RESTORE_WARNINGS
}
@@ -222,7 +224,7 @@ test_float(void)
"0.0E0", "-0.0E0", "1.5E0", "-2.5E0", "4.56789E6"};
for (size_t i = 0; i < sizeof(test_values) / sizeof(float); ++i) {
- SerdNode* node = serd_new_float(test_values[i]);
+ SerdNode* node = serd_new_float(NULL, test_values[i]);
const char* node_str = serd_node_string(node);
assert(!strcmp(node_str, test_strings[i]));
@@ -235,7 +237,7 @@ test_float(void)
const float value = serd_get_float(node);
assert(!memcmp(&value, &test_values[i], sizeof(value)));
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
}
@@ -245,14 +247,14 @@ check_get_float(const char* string,
const float expected)
{
SerdNode* const node = serd_new_literal(
- SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
+ NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
assert(node);
const float value = serd_get_float(node);
assert(!memcmp(&value, &expected, sizeof(value)));
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
static void
@@ -267,31 +269,34 @@ test_get_float(void)
SERD_DISABLE_CONVERSION_WARNINGS
- SerdNode* const nan = serd_new_string(SERD_STRING("unknown"));
+ SerdNode* const nan = serd_new_string(NULL, SERD_STRING("unknown"));
assert(isnan(serd_get_float(nan)));
- serd_node_free(nan);
+ serd_node_free(NULL, nan);
- SerdNode* const invalid = serd_new_literal(
- SERD_STRING("!invalid"), SERD_HAS_DATATYPE, SERD_STRING(NS_XSD "long"));
+ SerdNode* const invalid = serd_new_literal(NULL,
+ SERD_STRING("!invalid"),
+ SERD_HAS_DATATYPE,
+ SERD_STRING(NS_XSD "long"));
assert(isnan(serd_get_double(invalid)));
SERD_RESTORE_WARNINGS
- serd_node_free(invalid);
+ serd_node_free(NULL, invalid);
}
static void
test_integer(void)
{
- assert(!serd_new_integer(42, SERD_STRING("notauri")));
+ assert(!serd_new_integer(NULL, 42, SERD_STRING("notauri")));
const int64_t test_values[] = {0, -0, -23, 23, -12340, 1000, -1000};
const char* test_strings[] = {
"0", "0", "-23", "23", "-12340", "1000", "-1000"};
for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
- SerdNode* node = serd_new_integer(test_values[i], SERD_EMPTY_STRING());
+ SerdNode* node =
+ serd_new_integer(NULL, test_values[i], SERD_EMPTY_STRING());
const char* node_str = serd_node_string(node);
assert(!strcmp(node_str, test_strings[i]));
const size_t len = strlen(node_str);
@@ -302,7 +307,7 @@ test_integer(void)
assert(!strcmp(serd_node_string(datatype), NS_XSD "integer"));
assert(serd_get_integer(node) == test_values[i]);
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
}
@@ -312,12 +317,12 @@ check_get_integer(const char* string,
const int64_t expected)
{
SerdNode* const node = serd_new_literal(
- SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
+ NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
assert(node);
assert(serd_get_integer(node) == expected);
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
static void
@@ -336,8 +341,8 @@ test_get_integer(void)
static void
test_base64(void)
{
- assert(!serd_new_base64(&SERD_URI_NULL, 1, SERD_STRING("notauri")));
- assert(!serd_new_base64(&SERD_URI_NULL, 0, SERD_EMPTY_STRING()));
+ assert(!serd_new_base64(NULL, &SERD_URI_NULL, 1, SERD_STRING("notauri")));
+ assert(!serd_new_base64(NULL, &SERD_URI_NULL, 0, SERD_EMPTY_STRING()));
// Test valid base64 blobs with a range of sizes
for (size_t size = 1; size < 256; ++size) {
@@ -346,7 +351,7 @@ test_base64(void)
data[i] = (uint8_t)((size + i) % 256);
}
- SerdNode* blob = serd_new_base64(data, size, SERD_EMPTY_STRING());
+ SerdNode* blob = serd_new_base64(NULL, data, size, SERD_EMPTY_STRING());
const char* blob_str = serd_node_string(blob);
const size_t max_size = serd_get_base64_size(blob);
uint8_t* out = (uint8_t*)calloc(1, max_size);
@@ -365,8 +370,8 @@ test_base64(void)
assert(datatype);
assert(!strcmp(serd_node_string(datatype), NS_XSD "base64Binary"));
- serd_node_free(blob);
- serd_free(out);
+ serd_node_free(NULL, blob);
+ free(out);
free(data);
}
}
@@ -377,7 +382,7 @@ check_get_base64(const char* string,
const char* expected)
{
SerdNode* const node = serd_new_literal(
- SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
+ NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
assert(node);
@@ -392,7 +397,7 @@ check_get_base64(const char* string,
assert(strlen(decoded) <= max_size);
free(decoded);
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
static void
@@ -402,14 +407,16 @@ test_get_base64(void)
check_get_base64("Zm9vYg==", NS_XSD "base64Binary", "foob");
check_get_base64(" \f\n\r\t\vZm9v \f\n\r\t\v", NS_XSD "base64Binary", "foo");
- SerdNode* const node = serd_new_literal(
- SERD_STRING("Zm9v"), SERD_HAS_DATATYPE, SERD_STRING(NS_XSD "base64Binary"));
+ SerdNode* const node = serd_new_literal(NULL,
+ SERD_STRING("Zm9v"),
+ SERD_HAS_DATATYPE,
+ SERD_STRING(NS_XSD "base64Binary"));
char small[2] = {0};
const SerdWriteResult r = serd_get_base64(node, sizeof(small), small);
assert(r.status == SERD_OVERFLOW);
- serd_node_free(node);
+ serd_node_free(NULL, node);
}
static void
@@ -420,69 +427,75 @@ test_node_equals(void)
static const SerdStringView replacement_char = {
(const char*)replacement_char_str, 3};
- SerdNode* lhs = serd_new_string(replacement_char);
- SerdNode* rhs = serd_new_string(SERD_STRING("123"));
+ SerdNode* lhs = serd_new_string(NULL, replacement_char);
+ SerdNode* rhs = serd_new_string(NULL, SERD_STRING("123"));
assert(serd_node_equals(lhs, lhs));
assert(!serd_node_equals(lhs, rhs));
- assert(!serd_node_copy(NULL));
+ assert(!serd_node_copy(NULL, NULL));
- serd_node_free(lhs);
- serd_node_free(rhs);
+ serd_node_free(NULL, lhs);
+ serd_node_free(NULL, rhs);
}
static void
test_node_from_syntax(void)
{
- SerdNode* const hello = serd_new_string(SERD_STRING("hello\""));
+ SerdNode* const hello = serd_new_string(NULL, SERD_STRING("hello\""));
assert(serd_node_length(hello) == 6);
assert(!serd_node_flags(hello));
assert(!strncmp(serd_node_string(hello), "hello\"", 6));
- serd_node_free(hello);
+ serd_node_free(NULL, hello);
}
static void
test_node_from_substring(void)
{
- SerdNode* const a_b = serd_new_string(SERD_SUBSTRING("a\"bc", 3));
+ SerdNode* const a_b = serd_new_string(NULL, SERD_SUBSTRING("a\"bc", 3));
assert(serd_node_length(a_b) == 3);
assert(!serd_node_flags(a_b));
assert(strlen(serd_node_string(a_b)) == 3);
assert(!strncmp(serd_node_string(a_b), "a\"b", 3));
- serd_node_free(a_b);
+ serd_node_free(NULL, a_b);
}
static void
check_copy_equals(const SerdNode* const node)
{
- SerdNode* const copy = serd_node_copy(node);
+ SerdNode* const copy = serd_node_copy(NULL, node);
assert(serd_node_equals(node, copy));
- serd_node_free(copy);
+ serd_node_free(NULL, copy);
}
static void
test_new(void)
{
- assert(!serd_node_new(SERD_URI,
+ assert(!serd_node_new(NULL,
+ SERD_URI,
SERD_STRING("http://example.org/"),
SERD_HAS_DATATYPE,
SERD_STRING("http://example.org/uris/cant/have/me")));
- assert(!serd_node_new(SERD_URI,
+ assert(!serd_node_new(NULL,
+ SERD_URI,
SERD_STRING("http://example.org/"),
SERD_HAS_LANGUAGE,
SERD_STRING("in-valid")));
- assert(!serd_node_new(SERD_BLANK,
+ assert(!serd_node_new(NULL,
+ SERD_BLANK,
SERD_STRING("b0"),
SERD_HAS_DATATYPE,
SERD_STRING("http://example.org/uris/cant/have/me")));
- assert(!serd_node_new(
- SERD_BLANK, SERD_STRING("b0"), SERD_HAS_LANGUAGE, SERD_STRING("in-valid")));
+ assert(!serd_node_new(NULL,
+ SERD_BLANK,
+ SERD_STRING("b0"),
+ SERD_HAS_LANGUAGE,
+ SERD_STRING("in-valid")));
}
static void
@@ -491,35 +504,46 @@ test_literal(void)
static const SerdStringView hello_str = SERD_STRING("hello");
static const SerdStringView empty_str = SERD_EMPTY_STRING();
- assert(!serd_new_literal(
- hello_str, SERD_HAS_DATATYPE | SERD_HAS_LANGUAGE, SERD_STRING("whatever")));
+ assert(!serd_new_literal(NULL,
+ hello_str,
+ SERD_HAS_DATATYPE | SERD_HAS_LANGUAGE,
+ SERD_STRING("whatever")));
- assert(!serd_new_literal(hello_str, SERD_HAS_DATATYPE, empty_str));
- assert(!serd_new_literal(hello_str, SERD_HAS_LANGUAGE, empty_str));
+ assert(!serd_new_literal(NULL, hello_str, SERD_HAS_DATATYPE, empty_str));
+ assert(!serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, empty_str));
- assert(!serd_new_literal(hello_str, SERD_HAS_DATATYPE, SERD_STRING("Type")));
- assert(!serd_new_literal(hello_str, SERD_HAS_DATATYPE, SERD_STRING("de")));
+ assert(
+ !serd_new_literal(NULL, hello_str, SERD_HAS_DATATYPE, SERD_STRING("Type")));
+ assert(
+ !serd_new_literal(NULL, hello_str, SERD_HAS_DATATYPE, SERD_STRING("de")));
- assert(!serd_new_literal(hello_str, SERD_HAS_LANGUAGE, SERD_STRING("3n")));
- assert(!serd_new_literal(hello_str, SERD_HAS_LANGUAGE, SERD_STRING("d3")));
- assert(!serd_new_literal(hello_str, SERD_HAS_LANGUAGE, SERD_STRING("d3")));
- assert(!serd_new_literal(hello_str, SERD_HAS_LANGUAGE, SERD_STRING("en-!")));
+ assert(
+ !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("3n")));
+ assert(
+ !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("d3")));
+ assert(
+ !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("d3")));
+ assert(
+ !serd_new_literal(NULL, hello_str, SERD_HAS_LANGUAGE, SERD_STRING("en-!")));
- SerdNode* hello2 = serd_new_string(SERD_STRING("hello\""));
+ SerdNode* hello2 = serd_new_string(NULL, SERD_STRING("hello\""));
assert(serd_node_length(hello2) == 6 &&
!strcmp(serd_node_string(hello2), "hello\""));
check_copy_equals(hello2);
- assert(!serd_new_literal(
- SERD_STRING("plain"), SERD_HAS_DATATYPE, SERD_STRING(NS_RDF "langString")));
+ assert(!serd_new_literal(NULL,
+ SERD_STRING("plain"),
+ SERD_HAS_DATATYPE,
+ SERD_STRING(NS_RDF "langString")));
- serd_node_free(hello2);
+ serd_node_free(NULL, hello2);
const char* lang_lit_str = "\"Hello\"@en-ca";
SerdNode* sliced_lang_lit =
- serd_new_literal(SERD_SUBSTRING(lang_lit_str + 1, 5),
+ serd_new_literal(NULL,
+ SERD_SUBSTRING(lang_lit_str + 1, 5),
SERD_HAS_LANGUAGE,
SERD_SUBSTRING(lang_lit_str + 8, 5));
@@ -529,11 +553,12 @@ test_literal(void)
assert(lang);
assert(!strcmp(serd_node_string(lang), "en-ca"));
check_copy_equals(sliced_lang_lit);
- serd_node_free(sliced_lang_lit);
+ serd_node_free(NULL, sliced_lang_lit);
const char* type_lit_str = "\"Hallo\"^^<http://example.org/Greeting>";
SerdNode* sliced_type_lit =
- serd_new_literal(SERD_SUBSTRING(type_lit_str + 1, 5),
+ serd_new_literal(NULL,
+ SERD_SUBSTRING(type_lit_str + 1, 5),
SERD_HAS_DATATYPE,
SERD_SUBSTRING(type_lit_str + 10, 27));
@@ -542,50 +567,53 @@ test_literal(void)
const SerdNode* const datatype = serd_node_datatype(sliced_type_lit);
assert(datatype);
assert(!strcmp(serd_node_string(datatype), "http://example.org/Greeting"));
- serd_node_free(sliced_type_lit);
+ serd_node_free(NULL, sliced_type_lit);
}
static void
test_blank(void)
{
- SerdNode* blank = serd_new_token(SERD_BLANK, SERD_STRING("b0"));
+ SerdNode* blank = serd_new_token(NULL, SERD_BLANK, SERD_STRING("b0"));
assert(serd_node_length(blank) == 2);
assert(serd_node_flags(blank) == 0);
assert(!strcmp(serd_node_string(blank), "b0"));
- serd_node_free(blank);
+ serd_node_free(NULL, blank);
}
static void
test_compare(void)
{
SerdNode* xsd_short = serd_new_token(
- SERD_URI, SERD_STRING("http://www.w3.org/2001/XMLSchema#short"));
+ NULL, SERD_URI, SERD_STRING("http://www.w3.org/2001/XMLSchema#short"));
- SerdNode* angst = serd_new_string(SERD_STRING("angst"));
+ SerdNode* angst = serd_new_string(NULL, SERD_STRING("angst"));
SerdNode* angst_de = serd_new_literal(
- SERD_STRING("angst"), SERD_HAS_LANGUAGE, SERD_STRING("de"));
+ NULL, SERD_STRING("angst"), SERD_HAS_LANGUAGE, SERD_STRING("de"));
SerdNode* angst_en = serd_new_literal(
- SERD_STRING("angst"), SERD_HAS_LANGUAGE, SERD_STRING("en"));
+ NULL, SERD_STRING("angst"), SERD_HAS_LANGUAGE, SERD_STRING("en"));
SerdNode* hallo = serd_new_literal(
- SERD_STRING("Hallo"), SERD_HAS_LANGUAGE, SERD_STRING("de"));
+ NULL, SERD_STRING("Hallo"), SERD_HAS_LANGUAGE, SERD_STRING("de"));
- SerdNode* hello = serd_new_string(SERD_STRING("Hello"));
- SerdNode* universe = serd_new_string(SERD_STRING("Universe"));
- SerdNode* integer = serd_new_integer(4, SERD_EMPTY_STRING());
- SerdNode* short_integer = serd_new_integer(4, SERD_STRING(NS_XSD "short"));
- SerdNode* blank = serd_new_token(SERD_BLANK, SERD_STRING("b1"));
+ SerdNode* hello = serd_new_string(NULL, SERD_STRING("Hello"));
+ SerdNode* universe = serd_new_string(NULL, SERD_STRING("Universe"));
+ SerdNode* integer = serd_new_integer(NULL, 4, SERD_EMPTY_STRING());
+ SerdNode* short_integer =
+ serd_new_integer(NULL, 4, SERD_STRING(NS_XSD "short"));
+ SerdNode* blank = serd_new_token(NULL, SERD_BLANK, SERD_STRING("b1"));
- SerdNode* uri = serd_new_uri(SERD_STRING("http://example.org/"));
+ SerdNode* uri = serd_new_uri(NULL, SERD_STRING("http://example.org/"));
SerdNode* aardvark =
- serd_new_literal(SERD_STRING("alex"),
+ serd_new_literal(NULL,
+ SERD_STRING("alex"),
SERD_HAS_DATATYPE,
SERD_STRING("http://example.org/Aardvark"));
- SerdNode* badger = serd_new_literal(SERD_STRING("bobby"),
+ SerdNode* badger = serd_new_literal(NULL,
+ SERD_STRING("bobby"),
SERD_HAS_DATATYPE,
SERD_STRING("http://example.org/Badger"));
@@ -602,19 +630,19 @@ test_compare(void)
assert(serd_node_compare(integer, short_integer) < 0);
assert(serd_node_compare(aardvark, badger) < 0);
- serd_node_free(uri);
- serd_node_free(blank);
- serd_node_free(short_integer);
- serd_node_free(integer);
- serd_node_free(badger);
- serd_node_free(aardvark);
- serd_node_free(universe);
- serd_node_free(hello);
- serd_node_free(hallo);
- serd_node_free(angst_en);
- serd_node_free(angst_de);
- serd_node_free(angst);
- serd_node_free(xsd_short);
+ serd_node_free(NULL, uri);
+ serd_node_free(NULL, blank);
+ serd_node_free(NULL, short_integer);
+ serd_node_free(NULL, integer);
+ serd_node_free(NULL, badger);
+ serd_node_free(NULL, aardvark);
+ serd_node_free(NULL, universe);
+ serd_node_free(NULL, hello);
+ serd_node_free(NULL, hallo);
+ serd_node_free(NULL, angst_en);
+ serd_node_free(NULL, angst_de);
+ serd_node_free(NULL, angst);
+ serd_node_free(NULL, xsd_short);
}
int
generated by cgit v1.2.1 (git 2.18.0) at 2024-07-07 11:04:07 +0000