Make Reader always read from a ByteSource

8 files changed, 169 insertions, 43 deletions

diff --git a/test/meson.build b/test/meson.build
index b6c2ce2f..5063277b 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -6,6 +6,7 @@ wrapper = meson.get_cross_property('exe_wrapper', '')
 
 unit_tests = [
   'byte_sink',
+  'byte_source',
   'caret',
   'env',
   'free_null',
@@ -160,25 +161,32 @@ if get_option('utils')
   # IO errors
 
   test('read_dir', serdi,
-       args: ['-e', 'file://@0@/'.format(meson.source_root())],
+       args: ['-e', meson.source_root()],
        env: test_env,
        should_fail: true,
        suite: 'io_errors')
 
   test('bulk_read_dir', serdi,
-       args: ['file://@0@/'.format(meson.source_root())],
+       args: [meson.source_root()],
        env: test_env,
        should_fail: true,
        suite: 'io_errors')
 
+  if host_machine.system() == 'linux'
+    test('unreadable', serdi,
+         args: ['/sys/bus/pci/rescan'],
+         env: test_env,
+         should_fail: true,
+         suite: 'io_errors')
+  endif
+
   test('write_error', files('test_write_error.py'),
        args: script_args + [serd_ttl],
        env: test_env,
        suite: 'io_errors')
 
   test('write_bad_file', serdi,
-       args: ['-w', '/does/not/exist.ttl',
-              'file://@0@/serd.ttl'.format(meson.source_root())],
+       args: ['-w', '/does/not/exist.ttl', meson.source_root() / 'serd.ttl'],
        env: test_env,
        should_fail: true,
        suite: 'io_errors')
diff --git a/test/test_byte_source.c b/test/test_byte_source.c
new file mode 100644
index 00000000..14ef5819
--- /dev/null
+++ b/test/test_byte_source.c
@@ -0,0 +1,40 @@
+/*
+  Copyright 2021 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#undef NDEBUG
+
+#include "serd/serd.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdio.h>
+
+static void
+test_bad_page_size(void)
+{
+  assert(!serd_byte_source_new_filename("file.ttl", 0));
+
+  assert(!serd_byte_source_new_function(
+    (SerdReadFunc)fread, (SerdStreamErrorFunc)ferror, NULL, NULL, NULL, 0));
+}
+
+int
+main(void)
+{
+  test_bad_page_size();
+
+  return 0;
+}
diff --git a/test/test_free_null.c b/test/test_free_null.c
index 15e751a9..28f7563f 100644
--- a/test/test_free_null.c
+++ b/test/test_free_null.c
@@ -24,6 +24,7 @@ int
 main(void)
 {
   serd_free(NULL);
+  serd_byte_source_free(NULL);
   serd_byte_sink_free(NULL);
   serd_node_free(NULL);
   serd_world_free(NULL);
diff --git a/test/test_overflow.c b/test/test_overflow.c
index 936187a9..6d5c6d0c 100644
--- a/test/test_overflow.c
+++ b/test/test_overflow.c
@@ -30,15 +30,17 @@ test_size(SerdWorld* const  world,
           const SerdSyntax  syntax,
           const size_t      stack_size)
 {
-  SerdSink*         sink = serd_sink_new(NULL, NULL, NULL);
+  SerdSink*         sink        = serd_sink_new(NULL, NULL, NULL);
+  SerdByteSource*   byte_source = serd_byte_source_new_string(str, NULL);
   SerdReader* const reader =
     serd_reader_new(world, syntax, 0u, sink, stack_size);
 
   assert(reader);
 
-  serd_reader_start_string(reader, str, NULL);
+  serd_reader_start(reader, byte_source);
   const SerdStatus st = serd_reader_read_document(reader);
   serd_reader_free(reader);
+  serd_byte_source_free(byte_source);
   serd_sink_free(sink);
 
   return st;
diff --git a/test/test_read_chunk.c b/test/test_read_chunk.c
index 78cd402e..f2681e32 100644
--- a/test/test_read_chunk.c
+++ b/test/test_read_chunk.c
@@ -94,20 +94,22 @@ main(void)
   SerdWorld* world = serd_world_new();
   SerdSink*  sink  = serd_sink_new(NULL, on_event, NULL);
 
+  SerdByteSource* byte_source =
+    serd_byte_source_new_string("@prefix eg: <http://example.org/> .\n"
+                                "@base <http://example.org/base> .\n"
+                                "eg:s1 eg:p1 eg:o1 ;\n"
+                                "      eg:p2 eg:o2 ,\n"
+                                "            eg:o3 .\n"
+                                "eg:s2 eg:p1 eg:o1 ;\n"
+                                "      eg:p2 eg:o2 .\n"
+                                "eg:s3 eg:p1 eg:o1 .\n"
+                                "eg:s4 eg:p1 [ eg:p3 eg:o1 ] .\n",
+                                NULL);
+
   SerdReader* reader = serd_reader_new(world, SERD_TURTLE, 0, sink, 4096);
   assert(reader);
 
-  assert(!serd_reader_start_string(reader,
-                                   "@prefix eg: <http://example.org/> .\n"
-                                   "@base <http://example.org/base> .\n"
-                                   "eg:s1 eg:p1 eg:o1 ;\n"
-                                   "      eg:p2 eg:o2 ,\n"
-                                   "            eg:o3 .\n"
-                                   "eg:s2 eg:p1 eg:o1 ;\n"
-                                   "      eg:p2 eg:o2 .\n"
-                                   "eg:s3 eg:p1 eg:o1 .\n"
-                                   "eg:s4 eg:p1 [ eg:p3 eg:o1 ] .\n",
-                                   NULL));
+  assert(!serd_reader_start(reader, byte_source));
 
   assert(!serd_reader_read_chunk(reader) && n_prefix == 1);
   assert(!serd_reader_read_chunk(reader) && n_base == 1);
@@ -121,6 +123,7 @@ main(void)
   assert(!serd_reader_finish(reader));
 
   serd_reader_free(reader);
+  serd_byte_source_free(byte_source);
   serd_sink_free(sink);
   serd_world_free(world);
 
diff --git a/test/test_reader.c b/test/test_reader.c
index 532411c6..7bc8ab48 100644
--- a/test/test_reader.c
+++ b/test/test_reader.c
@@ -32,6 +32,55 @@ count_statements(void* handle, const SerdEvent* event)
   return SERD_SUCCESS;
 }
 
+SERD_PURE_FUNC
+static size_t
+prepare_test_read(void* buf, size_t size, size_t nmemb, void* stream)
+{
+  assert(size == 1);
+  assert(nmemb == 1);
+
+  (void)buf;
+  (void)size;
+  (void)nmemb;
+  (void)stream;
+
+  return 0;
+}
+
+static int
+prepare_test_error(void* stream)
+{
+  (void)stream;
+  return 1;
+}
+
+static void
+test_prepare_error(void)
+{
+  SerdWorld* const world        = serd_world_new();
+  size_t           n_statements = 0;
+  FILE* const      f            = tmpfile();
+
+  SerdSink* const sink = serd_sink_new(&n_statements, count_statements, NULL);
+  assert(sink);
+
+  SerdReader* const reader = serd_reader_new(world, SERD_TURTLE, 0, sink, 4096);
+  assert(reader);
+
+  SerdByteSource* byte_source = serd_byte_source_new_function(
+    prepare_test_read, prepare_test_error, NULL, f, NULL, 1);
+
+  SerdStatus st = serd_reader_start(reader, byte_source);
+  assert(!st);
+
+  assert(serd_reader_read_document(reader) == SERD_ERR_UNKNOWN);
+
+  serd_byte_source_free(byte_source);
+  serd_reader_free(reader);
+  serd_sink_free(sink);
+  serd_world_free(world);
+}
+
 static void
 test_read_string(void)
 {
@@ -44,18 +93,33 @@ test_read_string(void)
   SerdReader* reader = serd_reader_new(world, SERD_TURTLE, 0u, sink, 4096);
   assert(reader);
 
-  // Test reading a string that ends exactly at the end of input (no newline)
-  assert(
-    !serd_reader_start_string(reader,
-                              "<http://example.org/s> <http://example.org/p> "
-                              "<http://example.org/o> .",
-                              NULL));
+  SerdByteSource* byte_source =
+    serd_byte_source_new_string("<http://example.org/s> <http://example.org/p> "
+                                "<http://example.org/o> .",
+                                NULL);
 
+  // Test reading a string that ends exactly at the end of input (no newline)
+  assert(!serd_reader_start(reader, byte_source));
   assert(!serd_reader_read_document(reader));
   assert(n_statements == 1);
   assert(!serd_reader_finish(reader));
 
+  // Test reading the same but as a chunk
+  serd_byte_source_free(byte_source);
+  n_statements = 0;
+  byte_source =
+    serd_byte_source_new_string("<http://example.org/s> <http://example.org/p> "
+                                "<http://example.org/o> , _:blank .",
+                                NULL);
+
+  assert(!serd_reader_start(reader, byte_source));
+  assert(!serd_reader_read_chunk(reader));
+  assert(n_statements == 2);
+  assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+  assert(!serd_reader_finish(reader));
+
   serd_reader_free(reader);
+  serd_byte_source_free(byte_source);
   serd_sink_free(sink);
   serd_world_free(world);
 }
@@ -120,13 +184,16 @@ test_read_eof_by_page(void)
   SerdSink*   sink    = serd_sink_new(&ignored, count_statements, NULL);
   SerdReader* reader  = serd_reader_new(world, SERD_TURTLE, 0u, sink, 4096);
 
-  serd_reader_start_stream(
-    reader, (SerdReadFunc)fread, (SerdStreamErrorFunc)ferror, temp, NULL, 4096);
+  SerdByteSource* byte_source = serd_byte_source_new_function(
+    (SerdReadFunc)fread, (SerdStreamErrorFunc)ferror, NULL, temp, NULL, 4096);
 
+  assert(serd_reader_start(reader, byte_source) == SERD_SUCCESS);
   assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
   assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
   assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+  assert(!serd_reader_finish(reader));
 
+  serd_byte_source_free(byte_source);
   serd_reader_free(reader);
   serd_sink_free(sink);
   serd_world_free(world);
@@ -142,19 +209,23 @@ test_read_eof_by_byte(void)
   SerdSink*   sink    = serd_sink_new(&ignored, count_statements, NULL);
   SerdReader* reader  = serd_reader_new(world, SERD_TURTLE, 0u, sink, 4096);
 
-  size_t n_reads = 0u;
-  serd_reader_start_stream(reader,
-                           (SerdReadFunc)eof_test_read,
-                           (SerdStreamErrorFunc)eof_test_error,
-                           &n_reads,
-                           NULL,
-                           1);
+  size_t          n_reads = 0u;
+  SerdByteSource* byte_source =
+    serd_byte_source_new_function((SerdReadFunc)eof_test_read,
+                                  (SerdStreamErrorFunc)eof_test_error,
+                                  NULL,
+                                  &n_reads,
+                                  NULL,
+                                  1);
 
+  assert(serd_reader_start(reader, byte_source) == SERD_SUCCESS);
   assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
   assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
   assert(serd_reader_read_chunk(reader) == SERD_SUCCESS);
   assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+  assert(!serd_reader_finish(reader));
 
+  serd_byte_source_free(byte_source);
   serd_reader_free(reader);
   serd_sink_free(sink);
   serd_world_free(world);
@@ -175,8 +246,10 @@ test_read_chunks(void)
     serd_reader_new(world, SERD_TURTLE, 0u, sink, 4096);
   assert(reader);
 
-  SerdStatus st = serd_reader_start_stream(
-    reader, (SerdReadFunc)fread, (SerdStreamErrorFunc)ferror, f, NULL, 1);
+  SerdByteSource* byte_source = serd_byte_source_new_function(
+    (SerdReadFunc)fread, (SerdStreamErrorFunc)ferror, NULL, f, NULL, 1);
+
+  SerdStatus st = serd_reader_start(reader, byte_source);
   assert(st == SERD_SUCCESS);
 
   // Write two statement separated by null characters
@@ -217,6 +290,7 @@ test_read_chunks(void)
   assert(st == SERD_FAILURE);
   assert(n_statements == 2);
 
+  serd_byte_source_free(byte_source);
   serd_reader_free(reader);
   serd_sink_free(sink);
   fclose(f);
@@ -226,6 +300,7 @@ test_read_chunks(void)
 int
 main(void)
 {
+  test_prepare_error();
   test_read_string();
   test_read_eof_by_page();
   test_read_eof_by_byte();
diff --git a/test/test_reader_writer.c b/test/test_reader_writer.c
index 8671a649..3a9bf7c9 100644
--- a/test/test_reader_writer.c
+++ b/test/test_reader_writer.c
@@ -19,7 +19,6 @@
 #include "serd/serd.h"
 
 #include <assert.h>
-#include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
@@ -149,8 +148,8 @@ test_reader(const char* path)
   SerdReader* reader = serd_reader_new(world, SERD_TURTLE, 0u, sink, 4096);
   assert(reader);
 
-  assert(serd_reader_read_document(reader) == SERD_FAILURE);
-  assert(serd_reader_read_chunk(reader) == SERD_FAILURE);
+  assert(serd_reader_read_document(reader) == SERD_ERR_BAD_CALL);
+  assert(serd_reader_read_chunk(reader) == SERD_ERR_BAD_CALL);
 
   serd_reader_add_blank_prefix(reader, "tmp");
 
@@ -163,14 +162,12 @@ test_reader(const char* path)
 #  pragma GCC diagnostic pop
 #endif
 
-  assert(serd_reader_start_file(reader, "http://notafile", false));
-  assert(serd_reader_start_file(reader, "file://invalid", false));
-  assert(serd_reader_start_file(reader, "file:///nonexistant", false));
-
-  assert(!serd_reader_start_file(reader, path, true));
+  SerdByteSource* byte_source = serd_byte_source_new_filename(path, 4096);
+  assert(!serd_reader_start(reader, byte_source));
   assert(!serd_reader_read_document(reader));
   assert(n_statements == 6);
   serd_reader_finish(reader);
+  serd_byte_source_free(byte_source);
 
   serd_reader_free(reader);
   serd_sink_free(sink);
diff --git a/test/test_string.c b/test/test_string.c
index 5bc304d1..495138d8 100644
--- a/test/test_string.c
+++ b/test/test_string.c
@@ -44,7 +44,7 @@ test_strerror(void)
 {
   const char* msg = serd_strerror(SERD_SUCCESS);
   assert(!strcmp(msg, "Success"));
-  for (int i = SERD_FAILURE; i <= SERD_ERR_NO_DATA; ++i) {
+  for (int i = SERD_FAILURE; i <= SERD_ERR_BAD_CALL; ++i) {
     msg = serd_strerror((SerdStatus)i);
     assert(strcmp(msg, "Success"));
   }