diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/meson.build | 1 | ||||
| -rw-r--r-- | test/test_free_null.c | 2 | ||||
| -rw-r--r-- | test/test_reader_writer.c | 109 | ||||
| -rw-r--r-- | test/test_sink.c | 151 | ||||
| -rw-r--r-- | test/test_writer.c | 31 |
5 files changed, 226 insertions, 68 deletions
diff --git a/test/meson.build b/test/meson.build index f6f56c2b..5742c545 100644 --- a/test/meson.build +++ b/test/meson.build @@ -123,6 +123,7 @@ unit_tests = [ 'free_null', 'node', 'reader_writer', + 'sink', 'string', 'uri', 'writer', diff --git a/test/test_free_null.c b/test/test_free_null.c index 10ff4d10..d3248cb5 100644 --- a/test/test_free_null.c +++ b/test/test_free_null.c @@ -7,6 +7,7 @@ #include "serd/memory.h" #include "serd/node.h" #include "serd/reader.h" +#include "serd/sink.h" #include "serd/writer.h" #include <stddef.h> @@ -17,6 +18,7 @@ main(void) serd_free(NULL); serd_node_free(NULL); serd_env_free(NULL); + serd_sink_free(NULL); serd_reader_free(NULL); serd_writer_free(NULL); diff --git a/test/test_reader_writer.c b/test/test_reader_writer.c index 3b656c2e..96c81d12 100644 --- a/test/test_reader_writer.c +++ b/test/test_reader_writer.c @@ -185,17 +185,16 @@ test_read_nquads_chunks(const char* const path) fseek(f, 0, SEEK_SET); ReaderTest* const rt = (ReaderTest*)calloc(1, sizeof(ReaderTest)); - SerdReader* const reader = serd_reader_new(SERD_NQUADS, - rt, - free, - test_base_sink, - test_prefix_sink, - test_statement_sink, - test_end_sink); + SerdSink* const sink = serd_sink_new(rt, NULL); + SerdReader* const reader = serd_reader_new(SERD_NQUADS, sink); assert(reader); - assert(serd_reader_handle(reader) == rt); + assert(sink); assert(f); + serd_sink_set_base_func(sink, test_base_sink); + serd_sink_set_prefix_func(sink, test_prefix_sink); + serd_sink_set_statement_func(sink, test_statement_sink); + serd_sink_set_end_func(sink, test_end_sink); SerdStatus st = serd_reader_start_stream(reader, f, NULL, false); assert(st == SERD_SUCCESS); @@ -243,6 +242,8 @@ test_read_nquads_chunks(const char* const path) assert(serd_reader_read_chunk(reader) == SERD_FAILURE); serd_reader_free(reader); + serd_sink_free(sink); + free(rt); fclose(f); remove(path); } @@ -265,17 +266,16 @@ test_read_turtle_chunks(const char* const path) fseek(f, 0, SEEK_SET); ReaderTest* const rt = (ReaderTest*)calloc(1, sizeof(ReaderTest)); - SerdReader* const reader = serd_reader_new(SERD_TURTLE, - rt, - free, - test_base_sink, - test_prefix_sink, - test_statement_sink, - test_end_sink); + SerdSink* const sink = serd_sink_new(rt, NULL); + SerdReader* const reader = serd_reader_new(SERD_TURTLE, sink); assert(reader); - assert(serd_reader_handle(reader) == rt); + assert(sink); assert(f); + serd_sink_set_base_func(sink, test_base_sink); + serd_sink_set_prefix_func(sink, test_prefix_sink); + serd_sink_set_statement_func(sink, test_statement_sink); + serd_sink_set_end_func(sink, test_end_sink); SerdStatus st = serd_reader_start_stream(reader, f, NULL, false); assert(st == SERD_SUCCESS); @@ -339,6 +339,8 @@ test_read_turtle_chunks(const char* const path) assert(serd_reader_read_chunk(reader) == SERD_FAILURE); serd_reader_free(reader); + serd_sink_free(sink); + free(rt); fclose(f); remove(path); } @@ -347,16 +349,16 @@ static void test_read_string(void) { ReaderTest* rt = (ReaderTest*)calloc(1, sizeof(ReaderTest)); - SerdReader* reader = serd_reader_new(SERD_TURTLE, - rt, - free, - test_base_sink, - test_prefix_sink, - test_statement_sink, - test_end_sink); + SerdSink* sink = serd_sink_new(rt, NULL); + SerdReader* reader = serd_reader_new(SERD_TURTLE, sink); assert(reader); - assert(serd_reader_handle(reader) == rt); + assert(sink); + + serd_sink_set_base_func(sink, test_base_sink); + serd_sink_set_prefix_func(sink, test_prefix_sink); + serd_sink_set_statement_func(sink, test_statement_sink); + serd_sink_set_end_func(sink, test_end_sink); // Test reading a string that ends exactly at the end of input (no newline) const SerdStatus st = @@ -371,6 +373,8 @@ test_read_string(void) assert(rt->n_end == 0); serd_reader_free(reader); + serd_sink_free(sink); + free(rt); } static size_t @@ -425,14 +429,8 @@ test_write_errors(void) SerdWriter* const writer = serd_writer_new(syntax, style, env, faulty_sink, &ctx); - SerdReader* const reader = - serd_reader_new(SERD_TRIG, - writer, - NULL, - (SerdBaseFunc)serd_writer_set_base_uri, - (SerdPrefixFunc)serd_writer_set_prefix, - (SerdStatementFunc)serd_writer_write_statement, - (SerdEndFunc)serd_writer_end_anon); + const SerdSink* const sink = serd_writer_sink(writer); + SerdReader* const reader = serd_reader_new(SERD_TRIG, sink); serd_reader_set_error_sink(reader, quiet_error_sink, NULL); serd_writer_set_error_sink(writer, quiet_error_sink, NULL); @@ -463,10 +461,10 @@ test_writer(const char* const path) SerdNode* lit = serd_new_string(serd_string("hello")); - assert(serd_writer_set_base_uri(writer, lit)); - assert(serd_writer_set_prefix(writer, lit, lit)); - assert(serd_writer_end_anon(writer, NULL)); - assert(serd_writer_env(writer) == env); + const SerdSink* const iface = serd_writer_sink(writer); + assert(serd_sink_write_base(iface, lit)); + assert(serd_sink_write_prefix(iface, lit, lit)); + assert(serd_sink_write_end(iface, lit)); static const uint8_t buf[] = {0xEF, 0xBF, 0xBD, 0}; const SerdStringView buf_view = {(const char*)buf, 3}; @@ -478,8 +476,7 @@ test_writer(const char* const path) // Write 3 invalid statements (should write nothing) const SerdNode* junk[][3] = {{s, o, o}, {o, p, o}, {s, o, p}}; for (size_t i = 0; i < sizeof(junk) / (sizeof(SerdNode*) * 3); ++i) { - assert(serd_writer_write_statement( - writer, 0, NULL, junk[i][0], junk[i][1], junk[i][2])); + assert(serd_sink_write(iface, 0, junk[i][0], junk[i][1], junk[i][2], NULL)); } const SerdStringView urn_Type = serd_string("urn:Type"); @@ -490,8 +487,8 @@ test_writer(const char* const path) const SerdNode* good[][3] = {{s, p, o}, {s, p, t}, {s, p, l}}; for (size_t i = 0; i < sizeof(good) / (sizeof(SerdNode*) * 3); ++i) { - assert(!serd_writer_write_statement( - writer, 0, NULL, good[i][0], good[i][1], good[i][2])); + assert( + !serd_sink_write(iface, 0, good[i][0], good[i][1], good[i][2], NULL)); } // Write statements with bad UTF-8 (should be replaced) @@ -499,16 +496,15 @@ test_writer(const char* const path) const SerdStringView bad_view = {(const char*)bad_str, 4}; SerdNode* bad_lit = serd_new_string(bad_view); SerdNode* bad_uri = serd_new_uri(bad_view); - assert(!serd_writer_write_statement(writer, 0, NULL, s, p, bad_lit)); - assert(!serd_writer_write_statement(writer, 0, NULL, s, p, bad_uri)); - + assert(!serd_sink_write(iface, 0, s, p, bad_lit, 0)); + assert(!serd_sink_write(iface, 0, s, p, bad_uri, 0)); serd_node_free(bad_uri); serd_node_free(bad_lit); // Write 1 valid statement - serd_node_free(o); - o = serd_new_string(serd_string("hello")); - assert(!serd_writer_write_statement(writer, 0, NULL, s, p, o)); + SerdNode* const hello = serd_new_string(serd_string("hello")); + assert(!serd_sink_write(iface, 0, s, p, hello, 0)); + serd_node_free(hello); serd_writer_free(writer); serd_node_free(lit); @@ -541,17 +537,16 @@ test_writer(const char* const path) static void test_reader(const char* path) { - ReaderTest* rt = (ReaderTest*)calloc(1, sizeof(ReaderTest)); - SerdReader* reader = serd_reader_new(SERD_TURTLE, - rt, - free, - test_base_sink, - test_prefix_sink, - test_statement_sink, - test_end_sink); - + ReaderTest* rt = (ReaderTest*)calloc(1, sizeof(ReaderTest)); + SerdSink* const sink = serd_sink_new(rt, NULL); + SerdReader* reader = serd_reader_new(SERD_TURTLE, sink); + assert(sink); assert(reader); - assert(serd_reader_handle(reader) == rt); + + serd_sink_set_base_func(sink, test_base_sink); + serd_sink_set_prefix_func(sink, test_prefix_sink); + serd_sink_set_statement_func(sink, test_statement_sink); + serd_sink_set_end_func(sink, test_end_sink); assert(serd_reader_read_chunk(reader) == SERD_FAILURE); @@ -615,6 +610,8 @@ test_reader(const char* path) } serd_reader_free(reader); + serd_sink_free(sink); + free(rt); } int diff --git a/test/test_sink.c b/test/test_sink.c new file mode 100644 index 00000000..944dea1a --- /dev/null +++ b/test/test_sink.c @@ -0,0 +1,151 @@ +// Copyright 2019-2020 David Robillard <d@drobilla.net> +// SPDX-License-Identifier: ISC + +#undef NDEBUG + +#include "serd/env.h" +#include "serd/node.h" +#include "serd/sink.h" +#include "serd/statement.h" +#include "serd/status.h" +#include "serd/string_view.h" + +#include <assert.h> +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> + +#define NS_EG "http://example.org/" + +typedef struct { + const SerdNode* last_base; + const SerdNode* last_name; + const SerdNode* last_namespace; + const SerdNode* last_end; + const SerdNode* last_subject; + const SerdNode* last_predicate; + const SerdNode* last_object; + const SerdNode* last_graph; + SerdStatus return_status; +} State; + +static SerdStatus +on_base(void* handle, const SerdNode* uri) +{ + State* state = (State*)handle; + + state->last_base = uri; + return state->return_status; +} + +static SerdStatus +on_prefix(void* handle, const SerdNode* name, const SerdNode* uri) +{ + State* state = (State*)handle; + + state->last_name = name; + state->last_namespace = uri; + return state->return_status; +} + +static SerdStatus +on_statement(void* handle, + SerdStatementFlags flags, + const SerdNode* const graph, + const SerdNode* const subject, + const SerdNode* const predicate, + const SerdNode* const object) +{ + (void)flags; + + State* state = (State*)handle; + + state->last_subject = subject; + state->last_predicate = predicate; + state->last_object = object; + state->last_graph = graph; + + return state->return_status; +} + +static SerdStatus +on_end(void* handle, const SerdNode* node) +{ + State* state = (State*)handle; + + state->last_end = node; + return state->return_status; +} + +static void +test_callbacks(void) +{ + SerdNode* const base = serd_new_uri(serd_string(NS_EG)); + SerdNode* const name = serd_new_string(serd_string("eg")); + SerdNode* const uri = serd_new_uri(serd_string(NS_EG "uri")); + SerdNode* const blank = serd_new_blank(serd_string("b1")); + SerdEnv* env = serd_env_new(serd_node_string_view(base)); + State state = {0, 0, 0, 0, 0, 0, 0, 0, SERD_SUCCESS}; + + // Call functions on a sink with no functions set + + SerdSink* null_sink = serd_sink_new(&state, NULL); + assert(!serd_sink_write_base(null_sink, base)); + assert(!serd_sink_write_prefix(null_sink, name, uri)); + assert(!serd_sink_write(null_sink, 0, base, uri, blank, NULL)); + assert(!serd_sink_write_end(null_sink, blank)); + serd_sink_free(null_sink); + + // Try again with a sink that has the event handler set + + SerdSink* sink = serd_sink_new(&state, NULL); + serd_sink_set_base_func(sink, on_base); + serd_sink_set_prefix_func(sink, on_prefix); + serd_sink_set_statement_func(sink, on_statement); + serd_sink_set_end_func(sink, on_end); + + assert(!serd_sink_write_base(sink, base)); + assert(serd_node_equals(state.last_base, base)); + + assert(!serd_sink_write_prefix(sink, name, uri)); + assert(serd_node_equals(state.last_name, name)); + assert(serd_node_equals(state.last_namespace, uri)); + + assert(!serd_sink_write(sink, 0, base, uri, blank, NULL)); + assert(serd_node_equals(state.last_subject, base)); + assert(serd_node_equals(state.last_predicate, uri)); + assert(serd_node_equals(state.last_object, blank)); + assert(!state.last_graph); + + assert(!serd_sink_write_end(sink, blank)); + assert(serd_node_equals(state.last_end, blank)); + + serd_sink_free(sink); + serd_env_free(env); + serd_node_free(blank); + serd_node_free(uri); + serd_node_free(name); + serd_node_free(base); +} + +static void +test_free(void) +{ + // Free of null should (as always) not crash + serd_sink_free(NULL); + + // Set up a sink with dynamically allocated data and a free function + uintptr_t* data = (uintptr_t*)calloc(1, sizeof(uintptr_t)); + SerdSink* sink = serd_sink_new(data, free); + + // Free the sink, which should free the data (rely on valgrind or sanitizers) + serd_sink_free(sink); +} + +int +main(void) +{ + test_callbacks(); + test_free(); + return 0; +} diff --git a/test/test_writer.c b/test/test_writer.c index 0c78495e..5a4e5ab0 100644 --- a/test/test_writer.c +++ b/test/test_writer.c @@ -7,6 +7,7 @@ #include "serd/env.h" #include "serd/memory.h" #include "serd/node.h" +#include "serd/sink.h" #include "serd/statement.h" #include "serd/status.h" #include "serd/string_view.h" @@ -31,7 +32,8 @@ test_write_bad_prefix(void) SerdNode* name = serd_new_string(serd_string("eg")); SerdNode* uri = serd_new_uri(serd_string("rel")); - assert(serd_writer_set_prefix(writer, name, uri) == SERD_BAD_ARG); + assert(serd_sink_write_prefix(serd_writer_sink(writer), name, uri) == + SERD_BAD_ARG); char* const out = serd_buffer_sink_finish(&buffer); @@ -58,7 +60,7 @@ test_write_long_literal(void) SerdNode* p = serd_new_uri(serd_string("http://example.org/p")); SerdNode* o = serd_new_string(serd_string("hello \"\"\"world\"\"\"!")); - assert(!serd_writer_write_statement(writer, 0, NULL, s, p, o)); + assert(!serd_sink_write(serd_writer_sink(writer), 0, s, p, o, NULL)); serd_node_free(o); serd_node_free(p); @@ -95,11 +97,13 @@ test_writer_cleanup(void) SerdEnv* env = serd_env_new(serd_empty_string()); SerdWriter* writer = serd_writer_new(SERD_TURTLE, 0U, env, null_sink, NULL); + const SerdSink* sink = serd_writer_sink(writer); + SerdNode* s = serd_new_uri(serd_string("http://example.org/s")); SerdNode* p = serd_new_uri(serd_string("http://example.org/p")); SerdNode* o = serd_new_blank(serd_string("start")); - st = serd_writer_write_statement(writer, SERD_ANON_O_BEGIN, NULL, s, p, o); + st = serd_sink_write(sink, SERD_ANON_O_BEGIN, s, p, o, NULL); assert(!st); // Write the start of several nested anonymous objects @@ -109,8 +113,7 @@ test_writer_cleanup(void) SerdNode* next_o = serd_new_blank(serd_string(buf)); - st = serd_writer_write_statement( - writer, SERD_ANON_O_BEGIN, NULL, o, p, next_o); + st = serd_sink_write(sink, SERD_ANON_O_BEGIN, o, p, next_o, NULL); serd_node_free(o); o = next_o; @@ -121,7 +124,9 @@ test_writer_cleanup(void) assert(!(st = serd_writer_set_base_uri(writer, NULL))); // Set the base to an empty URI - assert(!(st = serd_writer_set_base_uri(writer, NULL))); + SerdNode* empty_uri = serd_new_uri(serd_string("")); + assert(!(st = serd_sink_write_base(sink, empty_uri))); + serd_node_free(empty_uri); // Free (which could leak if the writer doesn't clean up the stack properly) serd_node_free(o); @@ -144,6 +149,8 @@ test_strict_write(void) assert(writer); + const SerdSink* const sink = serd_writer_sink(writer); + const uint8_t bad_str[] = {0xFF, 0x90, 'h', 'i', 0}; SerdNode* s = serd_new_uri(serd_string("http://example.org/s")); @@ -152,11 +159,8 @@ test_strict_write(void) SerdNode* bad_lit = serd_new_string(serd_string((const char*)bad_str)); SerdNode* bad_uri = serd_new_uri(serd_string((const char*)bad_str)); - assert(serd_writer_write_statement(writer, 0, NULL, s, p, bad_lit) == - SERD_BAD_TEXT); - - assert(serd_writer_write_statement(writer, 0, NULL, s, p, bad_uri) == - SERD_BAD_TEXT); + assert(serd_sink_write(sink, 0, s, p, bad_lit, NULL) == SERD_BAD_TEXT); + assert(serd_sink_write(sink, 0, s, p, bad_uri, NULL) == SERD_BAD_TEXT); serd_node_free(bad_uri); serd_node_free(bad_lit); @@ -194,7 +198,10 @@ test_write_error(void) writer = serd_writer_new(SERD_TURTLE, (SerdWriterFlags)0, env, error_sink, NULL); assert(writer); - st = serd_writer_write_statement(writer, 0U, NULL, u, u, u); + + const SerdSink* const sink = serd_writer_sink(writer); + + st = serd_sink_write(sink, 0U, u, u, u, NULL); assert(st == SERD_BAD_WRITE); serd_writer_free(writer); |