Rearrange source tree to be directly usable by dependants

This allows the LV2 source distribution to be used as an include path for
compilers and an LV2_PATH for applications, at the expense of self-contained
bundles.  That's a nice idea, but it made LV2 itself weird and annoying to
depend on.  This rearranges things so that directories in the source tree
correspond more closely to installation directories.

To make this possible, the "aux" directory in the documentation output has been
changed to "style", to avoid the reserved name "aux" on Windows.

4 files changed, 702 insertions, 1 deletions

diff --git a/test/atom_test_utils.c b/test/atom_test_utils.c
new file mode 100644
index 0000000..ae368c8
--- /dev/null
+++ b/test/atom_test_utils.c
@@ -0,0 +1,73 @@
+/*
+  Copyright 2012-2018 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.
+*/
+
+#include "lv2/atom/atom.h"
+#include "lv2/atom/forge.h"
+#include "lv2/atom/util.h"
+#include "lv2/log/log.h"
+#include "lv2/urid/urid.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static char**   uris   = NULL;
+static uint32_t n_uris = 0;
+
+static char*
+copy_string(const char* str)
+{
+  const size_t len = strlen(str);
+  char*        dup = (char*)malloc(len + 1);
+  memcpy(dup, str, len + 1);
+  return dup;
+}
+
+static LV2_URID
+urid_map(LV2_URID_Map_Handle handle, const char* uri)
+{
+  for (uint32_t i = 0; i < n_uris; ++i) {
+    if (!strcmp(uris[i], uri)) {
+      return i + 1;
+    }
+  }
+
+  uris             = (char**)realloc(uris, ++n_uris * sizeof(char*));
+  uris[n_uris - 1] = copy_string(uri);
+  return n_uris;
+}
+
+static void
+free_urid_map(void)
+{
+  for (uint32_t i = 0; i < n_uris; ++i) {
+    free(uris[i]);
+  }
+
+  free(uris);
+}
+
+LV2_LOG_FUNC(1, 2)
+static int
+test_fail(const char* fmt, ...)
+{
+  va_list args;
+  va_start(args, fmt);
+  fprintf(stderr, "error: ");
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+  return 1;
+}
diff --git a/test/meson.build b/test/meson.build
index 0b8339a..fe85e74 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -9,7 +9,7 @@
 codespell = find_program('codespell', required: get_option('tests'))
 if codespell.found()
   ignore = [
-    lv2_source_root / 'doc' / 'pygments.css',
+    lv2_source_root / 'doc' / 'style' / 'pygments.css',
     lv2_source_root / 'lv2specgen' / 'DTD',
     lv2_source_root / 'schemas.lv2' / 'doap.ttl',
   ]
@@ -108,3 +108,28 @@ endif
 if is_variable('pylint') and pylint.found()
   test('pylint', pylint, args: strict_python_scripts, suite: 'scripts')
 endif
+
+##############
+# Unit Tests #
+##############
+
+test_names = [
+  'atom',
+  'forge_overflow',
+]
+
+# Build and run tests
+if not get_option('tests').disabled()
+  foreach test_name : test_names
+    test(
+      test_name,
+      executable(
+        test_name,
+        files('test_@0@.c'.format(test_name)),
+        c_args: c_suppressions,
+        dependencies: lv2_dep,
+      ),
+      suite: 'unit',
+    )
+  endforeach
+endif
diff --git a/test/test_atom.c b/test/test_atom.c
new file mode 100644
index 0000000..5771694
--- /dev/null
+++ b/test/test_atom.c
@@ -0,0 +1,367 @@
+/*
+  Copyright 2012-2015 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.
+*/
+
+#include "atom_test_utils.c"
+
+#include "lv2/atom/atom.h"
+#include "lv2/atom/forge.h"
+#include "lv2/atom/util.h"
+#include "lv2/urid/urid.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+int
+main(void)
+{
+  LV2_URID_Map   map = {NULL, urid_map};
+  LV2_Atom_Forge forge;
+  lv2_atom_forge_init(&forge, &map);
+
+  LV2_URID eg_Object  = urid_map(NULL, "http://example.org/Object");
+  LV2_URID eg_one     = urid_map(NULL, "http://example.org/one");
+  LV2_URID eg_two     = urid_map(NULL, "http://example.org/two");
+  LV2_URID eg_three   = urid_map(NULL, "http://example.org/three");
+  LV2_URID eg_four    = urid_map(NULL, "http://example.org/four");
+  LV2_URID eg_true    = urid_map(NULL, "http://example.org/true");
+  LV2_URID eg_false   = urid_map(NULL, "http://example.org/false");
+  LV2_URID eg_path    = urid_map(NULL, "http://example.org/path");
+  LV2_URID eg_uri     = urid_map(NULL, "http://example.org/uri");
+  LV2_URID eg_urid    = urid_map(NULL, "http://example.org/urid");
+  LV2_URID eg_string  = urid_map(NULL, "http://example.org/string");
+  LV2_URID eg_literal = urid_map(NULL, "http://example.org/literal");
+  LV2_URID eg_tuple   = urid_map(NULL, "http://example.org/tuple");
+  LV2_URID eg_vector  = urid_map(NULL, "http://example.org/vector");
+  LV2_URID eg_vector2 = urid_map(NULL, "http://example.org/vector2");
+  LV2_URID eg_seq     = urid_map(NULL, "http://example.org/seq");
+
+#define BUF_SIZE 1024
+#define NUM_PROPS 15
+
+  uint8_t buf[BUF_SIZE];
+  lv2_atom_forge_set_buffer(&forge, buf, BUF_SIZE);
+
+  LV2_Atom_Forge_Frame obj_frame;
+  LV2_Atom*            obj = lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_object(&forge, &obj_frame, 0, eg_Object));
+
+  // eg_one = (Int)1
+  lv2_atom_forge_key(&forge, eg_one);
+  LV2_Atom_Int* one =
+    (LV2_Atom_Int*)lv2_atom_forge_deref(&forge, lv2_atom_forge_int(&forge, 1));
+  if (one->body != 1) {
+    return test_fail("%d != 1\n", one->body);
+  }
+
+  // eg_two = (Long)2
+  lv2_atom_forge_key(&forge, eg_two);
+  LV2_Atom_Long* two = (LV2_Atom_Long*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_long(&forge, 2));
+  if (two->body != 2) {
+    return test_fail("%ld != 2\n", (long)two->body);
+  }
+
+  // eg_three = (Float)3.0
+  lv2_atom_forge_key(&forge, eg_three);
+  LV2_Atom_Float* three = (LV2_Atom_Float*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_float(&forge, 3.0f));
+  if (three->body != 3) {
+    return test_fail("%f != 3\n", three->body);
+  }
+
+  // eg_four = (Double)4.0
+  lv2_atom_forge_key(&forge, eg_four);
+  LV2_Atom_Double* four = (LV2_Atom_Double*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_double(&forge, 4.0));
+  if (four->body != 4) {
+    return test_fail("%f != 4\n", four->body);
+  }
+
+  // eg_true = (Bool)1
+  lv2_atom_forge_key(&forge, eg_true);
+  LV2_Atom_Bool* t = (LV2_Atom_Bool*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_bool(&forge, true));
+  if (t->body != 1) {
+    return test_fail("%d != 1 (true)\n", t->body);
+  }
+
+  // eg_false = (Bool)0
+  lv2_atom_forge_key(&forge, eg_false);
+  LV2_Atom_Bool* f = (LV2_Atom_Bool*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_bool(&forge, false));
+  if (f->body != 0) {
+    return test_fail("%d != 0 (false)\n", f->body);
+  }
+
+  // eg_path = (Path)"/foo/bar"
+  const char*    pstr     = "/foo/bar";
+  const uint32_t pstr_len = (uint32_t)strlen(pstr);
+  lv2_atom_forge_key(&forge, eg_path);
+  LV2_Atom_String* path = (LV2_Atom_String*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_uri(&forge, pstr, pstr_len));
+  char* pbody = (char*)LV2_ATOM_BODY(path);
+  if (strcmp(pbody, pstr)) {
+    return test_fail("%s != \"%s\"\n", pbody, pstr);
+  }
+
+  // eg_uri = (URI)"http://example.org/value"
+  const char*    ustr     = "http://example.org/value";
+  const uint32_t ustr_len = (uint32_t)strlen(ustr);
+  lv2_atom_forge_key(&forge, eg_uri);
+  LV2_Atom_String* uri = (LV2_Atom_String*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_uri(&forge, ustr, ustr_len));
+  char* ubody = (char*)LV2_ATOM_BODY(uri);
+  if (strcmp(ubody, ustr)) {
+    return test_fail("%s != \"%s\"\n", ubody, ustr);
+  }
+
+  // eg_urid = (URID)"http://example.org/value"
+  LV2_URID eg_value = urid_map(NULL, "http://example.org/value");
+  lv2_atom_forge_key(&forge, eg_urid);
+  LV2_Atom_URID* urid = (LV2_Atom_URID*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_urid(&forge, eg_value));
+  if (urid->body != eg_value) {
+    return test_fail("%u != %u\n", urid->body, eg_value);
+  }
+
+  // eg_string = (String)"hello"
+  lv2_atom_forge_key(&forge, eg_string);
+  LV2_Atom_String* string = (LV2_Atom_String*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_string(&forge, "hello", strlen("hello")));
+  char* sbody = (char*)LV2_ATOM_BODY(string);
+  if (strcmp(sbody, "hello")) {
+    return test_fail("%s != \"hello\"\n", sbody);
+  }
+
+  // eg_literal = (Literal)"hello"@fr
+  lv2_atom_forge_key(&forge, eg_literal);
+  LV2_Atom_Literal* literal = (LV2_Atom_Literal*)lv2_atom_forge_deref(
+    &forge,
+    lv2_atom_forge_literal(&forge,
+                           "bonjour",
+                           strlen("bonjour"),
+                           0,
+                           urid_map(NULL, "http://lexvo.org/id/term/fr")));
+  char* lbody = (char*)LV2_ATOM_CONTENTS(LV2_Atom_Literal, literal);
+  if (strcmp(lbody, "bonjour")) {
+    return test_fail("%s != \"bonjour\"\n", lbody);
+  }
+
+  // eg_tuple = "foo",true
+  lv2_atom_forge_key(&forge, eg_tuple);
+  LV2_Atom_Forge_Frame tuple_frame;
+  LV2_Atom_Tuple*      tuple = (LV2_Atom_Tuple*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_tuple(&forge, &tuple_frame));
+  LV2_Atom_String* tup0 = (LV2_Atom_String*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_string(&forge, "foo", strlen("foo")));
+  LV2_Atom_Bool* tup1 = (LV2_Atom_Bool*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_bool(&forge, true));
+  lv2_atom_forge_pop(&forge, &tuple_frame);
+  LV2_Atom* i = lv2_atom_tuple_begin(tuple);
+  if (lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
+    return test_fail("Tuple iterator is empty\n");
+  }
+  LV2_Atom* tup0i = i;
+  if (!lv2_atom_equals((LV2_Atom*)tup0, tup0i)) {
+    return test_fail("Corrupt tuple element 0\n");
+  }
+  i = lv2_atom_tuple_next(i);
+  if (lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
+    return test_fail("Premature end of tuple iterator\n");
+  }
+  LV2_Atom* tup1i = i;
+  if (!lv2_atom_equals((LV2_Atom*)tup1, tup1i)) {
+    return test_fail("Corrupt tuple element 1\n");
+  }
+  i = lv2_atom_tuple_next(i);
+  if (!lv2_atom_tuple_is_end(LV2_ATOM_BODY(tuple), tuple->atom.size, i)) {
+    return test_fail("Tuple iter is not at end\n");
+  }
+
+  // eg_vector = (Vector<Int>)1,2,3,4
+  lv2_atom_forge_key(&forge, eg_vector);
+  int32_t          elems[] = {1, 2, 3, 4};
+  LV2_Atom_Vector* vector  = (LV2_Atom_Vector*)lv2_atom_forge_deref(
+    &forge,
+    lv2_atom_forge_vector(&forge, sizeof(int32_t), forge.Int, 4, elems));
+  void* vec_body = LV2_ATOM_CONTENTS(LV2_Atom_Vector, vector);
+  if (memcmp(elems, vec_body, sizeof(elems))) {
+    return test_fail("Corrupt vector\n");
+  }
+
+  // eg_vector2 = (Vector<Int>)1,2,3,4
+  lv2_atom_forge_key(&forge, eg_vector2);
+  LV2_Atom_Forge_Frame vec_frame;
+  LV2_Atom_Vector*     vector2 = (LV2_Atom_Vector*)lv2_atom_forge_deref(
+    &forge,
+    lv2_atom_forge_vector_head(&forge, &vec_frame, sizeof(int32_t), forge.Int));
+  for (unsigned e = 0; e < sizeof(elems) / sizeof(int32_t); ++e) {
+    lv2_atom_forge_int(&forge, elems[e]);
+  }
+  lv2_atom_forge_pop(&forge, &vec_frame);
+  if (!lv2_atom_equals(&vector->atom, &vector2->atom)) {
+    return test_fail("Vector != Vector2\n");
+  }
+
+  // eg_seq = (Sequence)1, 2
+  lv2_atom_forge_key(&forge, eg_seq);
+  LV2_Atom_Forge_Frame seq_frame;
+  LV2_Atom_Sequence*   seq = (LV2_Atom_Sequence*)lv2_atom_forge_deref(
+    &forge, lv2_atom_forge_sequence_head(&forge, &seq_frame, 0));
+  lv2_atom_forge_frame_time(&forge, 0);
+  lv2_atom_forge_int(&forge, 1);
+  lv2_atom_forge_frame_time(&forge, 1);
+  lv2_atom_forge_int(&forge, 2);
+  lv2_atom_forge_pop(&forge, &seq_frame);
+
+  lv2_atom_forge_pop(&forge, &obj_frame);
+
+  // Test equality
+  LV2_Atom_Int itwo = {{forge.Int, sizeof(int32_t)}, 2};
+  if (lv2_atom_equals((LV2_Atom*)one, (LV2_Atom*)two)) {
+    return test_fail("1 == 2.0\n");
+  } else if (lv2_atom_equals((LV2_Atom*)one, (LV2_Atom*)&itwo)) {
+    return test_fail("1 == 2\n");
+  } else if (!lv2_atom_equals((LV2_Atom*)one, (LV2_Atom*)one)) {
+    return test_fail("1 != 1\n");
+  }
+
+  unsigned n_events = 0;
+  LV2_ATOM_SEQUENCE_FOREACH (seq, ev) {
+    if (ev->time.frames != n_events) {
+      return test_fail("Corrupt event %u has bad time\n", n_events);
+    } else if (ev->body.type != forge.Int) {
+      return test_fail("Corrupt event %u has bad type\n", n_events);
+    } else if (((LV2_Atom_Int*)&ev->body)->body != (int)n_events + 1) {
+      return test_fail("Event %u != %u\n", n_events, n_events + 1);
+    }
+    ++n_events;
+  }
+
+  int n_props = 0;
+  LV2_ATOM_OBJECT_FOREACH ((LV2_Atom_Object*)obj, prop) {
+    if (!prop->key) {
+      return test_fail("Corrupt property %d has no key\n", n_props);
+    } else if (prop->context) {
+      return test_fail("Corrupt property %d has context\n", n_props);
+    }
+    ++n_props;
+  }
+
+  if (n_props != NUM_PROPS) {
+    return test_fail(
+      "Corrupt object has %d properties != %d\n", n_props, NUM_PROPS);
+  }
+
+  struct {
+    const LV2_Atom* one;
+    const LV2_Atom* two;
+    const LV2_Atom* three;
+    const LV2_Atom* four;
+    const LV2_Atom* affirmative;
+    const LV2_Atom* negative;
+    const LV2_Atom* path;
+    const LV2_Atom* uri;
+    const LV2_Atom* urid;
+    const LV2_Atom* string;
+    const LV2_Atom* literal;
+    const LV2_Atom* tuple;
+    const LV2_Atom* vector;
+    const LV2_Atom* vector2;
+    const LV2_Atom* seq;
+  } matches;
+
+  memset(&matches, 0, sizeof(matches));
+
+  LV2_Atom_Object_Query q[] = {{eg_one, &matches.one},
+                               {eg_two, &matches.two},
+                               {eg_three, &matches.three},
+                               {eg_four, &matches.four},
+                               {eg_true, &matches.affirmative},
+                               {eg_false, &matches.negative},
+                               {eg_path, &matches.path},
+                               {eg_uri, &matches.uri},
+                               {eg_urid, &matches.urid},
+                               {eg_string, &matches.string},
+                               {eg_literal, &matches.literal},
+                               {eg_tuple, &matches.tuple},
+                               {eg_vector, &matches.vector},
+                               {eg_vector2, &matches.vector2},
+                               {eg_seq, &matches.seq},
+                               LV2_ATOM_OBJECT_QUERY_END};
+
+  int n_matches = lv2_atom_object_query((LV2_Atom_Object*)obj, q);
+  for (int n = 0; n < 2; ++n) {
+    if (n_matches != n_props) {
+      return test_fail("Query failed, %d matches != %d\n", n_matches, n_props);
+    } else if (!lv2_atom_equals((LV2_Atom*)one, matches.one)) {
+      return test_fail("Bad match one\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)two, matches.two)) {
+      return test_fail("Bad match two\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)three, matches.three)) {
+      return test_fail("Bad match three\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)four, matches.four)) {
+      return test_fail("Bad match four\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)t, matches.affirmative)) {
+      return test_fail("Bad match true\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)f, matches.negative)) {
+      return test_fail("Bad match false\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)path, matches.path)) {
+      return test_fail("Bad match path\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)uri, matches.uri)) {
+      return test_fail("Bad match URI\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)string, matches.string)) {
+      return test_fail("Bad match string\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)literal, matches.literal)) {
+      return test_fail("Bad match literal\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)tuple, matches.tuple)) {
+      return test_fail("Bad match tuple\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)vector, matches.vector)) {
+      return test_fail("Bad match vector\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)vector, matches.vector2)) {
+      return test_fail("Bad match vector2\n");
+    } else if (!lv2_atom_equals((LV2_Atom*)seq, matches.seq)) {
+      return test_fail("Bad match sequence\n");
+    }
+    memset(&matches, 0, sizeof(matches));
+
+    // clang-format off
+    n_matches = lv2_atom_object_get((LV2_Atom_Object*)obj,
+                                    eg_one,     &matches.one,
+                                    eg_two,     &matches.two,
+                                    eg_three,   &matches.three,
+                                    eg_four,    &matches.four,
+                                    eg_true,    &matches.affirmative,
+                                    eg_false,   &matches.negative,
+                                    eg_path,    &matches.path,
+                                    eg_uri,     &matches.uri,
+                                    eg_urid,    &matches.urid,
+                                    eg_string,  &matches.string,
+                                    eg_literal, &matches.literal,
+                                    eg_tuple,   &matches.tuple,
+                                    eg_vector,  &matches.vector,
+                                    eg_vector2, &matches.vector2,
+                                    eg_seq,     &matches.seq,
+                                    0);
+    // clang-format on
+  }
+
+  free_urid_map();
+
+  return 0;
+}
diff --git a/test/test_forge_overflow.c b/test/test_forge_overflow.c
new file mode 100644
index 0000000..e00b40d
--- /dev/null
+++ b/test/test_forge_overflow.c
@@ -0,0 +1,236 @@
+/*
+  Copyright 2019 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.
+*/
+
+#include "atom_test_utils.c"
+
+#include "lv2/atom/atom.h"
+#include "lv2/atom/forge.h"
+#include "lv2/urid/urid.h"
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+static int
+test_string_overflow(void)
+{
+#define MAX_CHARS 15
+
+  static const size_t capacity = sizeof(LV2_Atom_String) + MAX_CHARS + 1;
+  static const char*  str      = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  uint8_t*       buf = (uint8_t*)malloc(capacity);
+  LV2_URID_Map   map = {NULL, urid_map};
+  LV2_Atom_Forge forge;
+  lv2_atom_forge_init(&forge, &map);
+
+  // Check that writing increasingly long strings fails at the right point
+  for (unsigned count = 0; count < MAX_CHARS; ++count) {
+    lv2_atom_forge_set_buffer(&forge, buf, capacity);
+
+    const LV2_Atom_Forge_Ref ref = lv2_atom_forge_string(&forge, str, count);
+    if (!ref) {
+      return test_fail("Failed to write %u byte string\n", count);
+    }
+  }
+
+  // Failure writing to an exactly full forge
+  if (lv2_atom_forge_string(&forge, str, MAX_CHARS + 1)) {
+    return test_fail("Successfully wrote past end of buffer\n");
+  }
+
+  // Failure writing body after successfully writing header
+  lv2_atom_forge_set_buffer(&forge, buf, sizeof(LV2_Atom) + 1);
+  if (lv2_atom_forge_string(&forge, "AB", 2)) {
+    return test_fail("Successfully wrote atom header past end\n");
+  }
+
+  free(buf);
+  return 0;
+}
+
+static int
+test_literal_overflow(void)
+{
+  static const size_t capacity = sizeof(LV2_Atom_Literal) + 2;
+
+  uint8_t*       buf = (uint8_t*)malloc(capacity);
+  LV2_URID_Map   map = {NULL, urid_map};
+  LV2_Atom_Forge forge;
+  lv2_atom_forge_init(&forge, &map);
+
+  // Failure in atom header
+  lv2_atom_forge_set_buffer(&forge, buf, 1);
+  if (lv2_atom_forge_literal(&forge, "A", 1, 0, 0)) {
+    return test_fail("Successfully wrote atom header past end\n");
+  }
+
+  // Failure in literal header
+  lv2_atom_forge_set_buffer(&forge, buf, sizeof(LV2_Atom) + 1);
+  if (lv2_atom_forge_literal(&forge, "A", 1, 0, 0)) {
+    return test_fail("Successfully wrote literal header past end\n");
+  }
+
+  // Success (only room for one character + null terminator)
+  lv2_atom_forge_set_buffer(&forge, buf, capacity);
+  if (!lv2_atom_forge_literal(&forge, "A", 1, 0, 0)) {
+    return test_fail("Failed to write small enough literal\n");
+  }
+
+  // Failure in body
+  lv2_atom_forge_set_buffer(&forge, buf, capacity);
+  if (lv2_atom_forge_literal(&forge, "AB", 2, 0, 0)) {
+    return test_fail("Successfully wrote literal body past end\n");
+  }
+
+  free(buf);
+  return 0;
+}
+
+static int
+test_sequence_overflow(void)
+{
+  static const size_t size = sizeof(LV2_Atom_Sequence) + 6 * sizeof(LV2_Atom);
+  LV2_URID_Map        map  = {NULL, urid_map};
+
+  // Test over a range that fails in the sequence header and event components
+  for (size_t capacity = 1; capacity < size; ++capacity) {
+    uint8_t* buf = (uint8_t*)malloc(capacity);
+
+    LV2_Atom_Forge forge;
+    lv2_atom_forge_init(&forge, &map);
+    lv2_atom_forge_set_buffer(&forge, buf, capacity);
+
+    LV2_Atom_Forge_Frame frame;
+    LV2_Atom_Forge_Ref   ref = lv2_atom_forge_sequence_head(&forge, &frame, 0);
+
+    assert(capacity >= sizeof(LV2_Atom_Sequence) || !frame.ref);
+    assert(capacity >= sizeof(LV2_Atom_Sequence) || !ref);
+    (void)ref;
+
+    lv2_atom_forge_frame_time(&forge, 0);
+    lv2_atom_forge_int(&forge, 42);
+    lv2_atom_forge_pop(&forge, &frame);
+
+    free(buf);
+  }
+
+  return 0;
+}
+
+static int
+test_vector_head_overflow(void)
+{
+  static const size_t size = sizeof(LV2_Atom_Vector) + 3 * sizeof(LV2_Atom);
+  LV2_URID_Map        map  = {NULL, urid_map};
+
+  // Test over a range that fails in the vector header and elements
+  for (size_t capacity = 1; capacity < size; ++capacity) {
+    uint8_t* buf = (uint8_t*)malloc(capacity);
+
+    LV2_Atom_Forge forge;
+    lv2_atom_forge_init(&forge, &map);
+    lv2_atom_forge_set_buffer(&forge, buf, capacity);
+
+    LV2_Atom_Forge_Frame frame;
+    LV2_Atom_Forge_Ref   ref =
+      lv2_atom_forge_vector_head(&forge, &frame, sizeof(int32_t), forge.Int);
+
+    assert(capacity >= sizeof(LV2_Atom_Vector) || !frame.ref);
+    assert(capacity >= sizeof(LV2_Atom_Vector) || !ref);
+    (void)ref;
+
+    lv2_atom_forge_int(&forge, 1);
+    lv2_atom_forge_int(&forge, 2);
+    lv2_atom_forge_int(&forge, 3);
+    lv2_atom_forge_pop(&forge, &frame);
+
+    free(buf);
+  }
+
+  return 0;
+}
+
+static int
+test_vector_overflow(void)
+{
+  static const size_t  size  = sizeof(LV2_Atom_Vector) + 3 * sizeof(LV2_Atom);
+  static const int32_t vec[] = {1, 2, 3};
+  LV2_URID_Map         map   = {NULL, urid_map};
+
+  // Test over a range that fails in the vector header and elements
+  for (size_t capacity = 1; capacity < size; ++capacity) {
+    uint8_t* buf = (uint8_t*)malloc(capacity);
+
+    LV2_Atom_Forge forge;
+    lv2_atom_forge_init(&forge, &map);
+    lv2_atom_forge_set_buffer(&forge, buf, capacity);
+
+    LV2_Atom_Forge_Ref ref =
+      lv2_atom_forge_vector(&forge, sizeof(int32_t), forge.Int, 3, vec);
+
+    assert(capacity >= sizeof(LV2_Atom_Vector) || !ref);
+    (void)ref;
+
+    free(buf);
+  }
+
+  return 0;
+}
+
+static int
+test_tuple_overflow(void)
+{
+  static const size_t size = sizeof(LV2_Atom_Tuple) + 3 * sizeof(LV2_Atom);
+  LV2_URID_Map        map  = {NULL, urid_map};
+
+  // Test over a range that fails in the tuple header and elements
+  for (size_t capacity = 1; capacity < size; ++capacity) {
+    uint8_t* buf = (uint8_t*)malloc(capacity);
+
+    LV2_Atom_Forge forge;
+    lv2_atom_forge_init(&forge, &map);
+    lv2_atom_forge_set_buffer(&forge, buf, capacity);
+
+    LV2_Atom_Forge_Frame frame;
+    LV2_Atom_Forge_Ref   ref = lv2_atom_forge_tuple(&forge, &frame);
+
+    assert(capacity >= sizeof(LV2_Atom_Tuple) || !frame.ref);
+    assert(capacity >= sizeof(LV2_Atom_Tuple) || !ref);
+    (void)ref;
+
+    lv2_atom_forge_int(&forge, 1);
+    lv2_atom_forge_float(&forge, 2.0f);
+    lv2_atom_forge_string(&forge, "three", 5);
+    lv2_atom_forge_pop(&forge, &frame);
+
+    free(buf);
+  }
+
+  return 0;
+}
+
+int
+main(void)
+{
+  const int ret = test_string_overflow() || test_literal_overflow() ||
+                  test_sequence_overflow() || test_vector_head_overflow() ||
+                  test_vector_overflow() || test_tuple_overflow();
+
+  free_urid_map();
+
+  return ret;
+}