aboutsummaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/.clang-tidy16
-rw-r--r--test/atom_test_utils.c66
-rw-r--r--test/cpp/.clang-tidy27
-rw-r--r--test/cpp/test_build.cpp54
-rw-r--r--test/headers/.clang-tidy22
-rw-r--r--test/headers/meson.build69
-rw-r--r--test/headers/test_headers.c42
-rw-r--r--test/meson.build180
-rw-r--r--test/test_atom.c354
-rw-r--r--test/test_build.c39
-rw-r--r--test/test_forge_overflow.c223
11 files changed, 1092 insertions, 0 deletions
diff --git a/test/.clang-tidy b/test/.clang-tidy
new file mode 100644
index 0000000..ef4d61f
--- /dev/null
+++ b/test/.clang-tidy
@@ -0,0 +1,16 @@
+# Copyright 2020-2025 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: 0BSD OR ISC
+
+Checks: >
+ -*-else-after-return,
+ -bugprone-easily-swappable-parameters,
+ -bugprone-multi-level-implicit-pointer-conversion,
+ -bugprone-suspicious-include,
+ -cert-err33-c,
+ -clang-diagnostic-unused-parameter,
+ -cppcoreguidelines-avoid-non-const-global-variables,
+ -llvmlibc-implementation-in-namespace,
+ -misc-unused-parameters,
+ -modernize-use-trailing-return-type,
+ -readability-function-cognitive-complexity,
+InheritParentConfig: true
diff --git a/test/atom_test_utils.c b/test/atom_test_utils.c
new file mode 100644
index 0000000..5c313a5
--- /dev/null
+++ b/test/atom_test_utils.c
@@ -0,0 +1,66 @@
+// Copyright 2012-2018 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#undef NDEBUG
+
+#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 <assert.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;
+ }
+ }
+
+ char** const new_uris = (char**)realloc(uris, (n_uris + 1) * sizeof(char*));
+ assert(new_uris);
+
+ uris = new_uris;
+ uris[n_uris++] = 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/cpp/.clang-tidy b/test/cpp/.clang-tidy
new file mode 100644
index 0000000..1fe1f27
--- /dev/null
+++ b/test/cpp/.clang-tidy
@@ -0,0 +1,27 @@
+# Copyright 2020-2025 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: 0BSD OR ISC
+
+Checks: >
+ -*-avoid-c-arrays,
+ -*-deprecated-headers,
+ -*-no-malloc,
+ -*-use-auto,
+ -bugprone-reserved-identifier,
+ -cert-dcl37-c,
+ -cert-dcl50-cpp,
+ -cert-dcl51-cpp,
+ -cppcoreguidelines-macro-usage,
+ -cppcoreguidelines-owning-memory,
+ -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+ -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+ -cppcoreguidelines-pro-type-cstyle-cast,
+ -cppcoreguidelines-pro-type-vararg,
+ -hicpp-no-array-decay,
+ -hicpp-use-nullptr,
+ -hicpp-vararg,
+ -llvmlibc-callee-namespace,
+ -modernize-use-nullptr,
+ -modernize-use-using,
+ -performance-enum-size,
+ -readability-implicit-bool-conversion,
+InheritParentConfig: true
diff --git a/test/cpp/test_build.cpp b/test/cpp/test_build.cpp
new file mode 100644
index 0000000..73868a4
--- /dev/null
+++ b/test/cpp/test_build.cpp
@@ -0,0 +1,54 @@
+// Copyright 2022 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#if defined(__clang__)
+_Pragma("clang diagnostic push")
+_Pragma("clang diagnostic ignored \"-Wold-style-cast\"")
+_Pragma("clang diagnostic ignored \"-Wzero-as-null-pointer-constant\"")
+#elif defined(__GNUC__)
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wsuggest-attribute=const\"")
+#endif
+
+#include <lv2/atom/atom.h> // IWYU pragma: keep
+#include <lv2/atom/forge.h> // IWYU pragma: keep
+#include <lv2/atom/util.h> // IWYU pragma: keep
+#include <lv2/buf-size/buf-size.h> // IWYU pragma: keep
+#include <lv2/core/attributes.h> // IWYU pragma: keep
+#include <lv2/core/lv2.h> // IWYU pragma: keep
+#include <lv2/core/lv2_util.h> // IWYU pragma: keep
+#include <lv2/data-access/data-access.h> // IWYU pragma: keep
+#include <lv2/dynmanifest/dynmanifest.h> // IWYU pragma: keep
+#include <lv2/event/event-helpers.h> // IWYU pragma: keep
+#include <lv2/event/event.h> // IWYU pragma: keep
+#include <lv2/instance-access/instance-access.h> // IWYU pragma: keep
+#include <lv2/log/log.h> // IWYU pragma: keep
+#include <lv2/log/logger.h> // IWYU pragma: keep
+#include <lv2/midi/midi.h> // IWYU pragma: keep
+#include <lv2/morph/morph.h> // IWYU pragma: keep
+#include <lv2/options/options.h> // IWYU pragma: keep
+#include <lv2/parameters/parameters.h> // IWYU pragma: keep
+#include <lv2/patch/patch.h> // IWYU pragma: keep
+#include <lv2/port-groups/port-groups.h> // IWYU pragma: keep
+#include <lv2/port-props/port-props.h> // IWYU pragma: keep
+#include <lv2/presets/presets.h> // IWYU pragma: keep
+#include <lv2/resize-port/resize-port.h> // IWYU pragma: keep
+#include <lv2/state/state.h> // IWYU pragma: keep
+#include <lv2/time/time.h> // IWYU pragma: keep
+#include <lv2/ui/ui.h> // IWYU pragma: keep
+#include <lv2/units/units.h> // IWYU pragma: keep
+#include <lv2/uri-map/uri-map.h> // IWYU pragma: keep
+#include <lv2/urid/urid.h> // IWYU pragma: keep
+#include <lv2/worker/worker.h> // IWYU pragma: keep
+
+int
+main()
+{
+ return 0;
+}
+
+#if defined(__clang__)
+_Pragma("clang diagnostic pop")
+#elif defined(__GNUC__)
+_Pragma("GCC diagnostic pop")
+#endif
diff --git a/test/headers/.clang-tidy b/test/headers/.clang-tidy
new file mode 100644
index 0000000..bf971cc
--- /dev/null
+++ b/test/headers/.clang-tidy
@@ -0,0 +1,22 @@
+# Copyright 2020-2024 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: 0BSD OR ISC
+
+Checks: >
+ *,
+ -*-macro-to-enum,
+ -*-magic-numbers,
+ -altera-*,
+ -bugprone-assignment-in-if-condition,
+ -bugprone-easily-swappable-parameters,
+ -bugprone-macro-parentheses,
+ -llvmlibc-restrict-system-libc-headers,
+ -performance-no-int-to-ptr,
+ -readability-identifier-length,
+CheckOptions:
+ - key: hicpp-uppercase-literal-suffix.NewSuffixes
+ value: L;U;f
+ - key: readability-uppercase-literal-suffix.NewSuffixes
+ value: L;U;f
+FormatStyle: file
+HeaderFilterRegex: 'lv2/.*\.h'
+WarningsAsErrors: '*'
diff --git a/test/headers/meson.build b/test/headers/meson.build
new file mode 100644
index 0000000..89ee4b8
--- /dev/null
+++ b/test/headers/meson.build
@@ -0,0 +1,69 @@
+# Copyright 2020-2022 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: 0BSD OR ISC
+
+header_c_suppressions = []
+
+if get_option('warning_level') == 'everything'
+ if cc.get_id() == 'clang'
+ header_c_suppressions += [
+ '-Wno-cast-align',
+ '-Wno-cast-qual',
+ '-Wno-declaration-after-statement',
+ '-Wno-padded',
+ '-Wno-unsafe-buffer-usage',
+ ]
+
+ if not meson.is_cross_build()
+ header_c_suppressions += [
+ '-Wno-poison-system-directories',
+ ]
+ endif
+
+ if host_machine.system() == 'windows'
+ header_c_suppressions += [
+ '-Wno-format-nonliteral',
+ ]
+ endif
+
+ elif cc.get_id() == 'gcc'
+ header_c_suppressions += [
+ '-Wno-cast-align',
+ '-Wno-cast-qual',
+ '-Wno-padded',
+ '-Wno-sign-conversion',
+ '-Wno-suggest-attribute=format',
+ '-Wno-unused-const-variable',
+ ]
+
+ if host_machine.system() == 'windows'
+ header_c_suppressions += [
+ '-Wno-sign-conversion',
+ ]
+ endif
+
+ elif cc.get_id() == 'msvc'
+ header_c_suppressions += [
+ '/wd4820', # padding added after construct
+ ]
+ endif
+endif
+
+if cc.get_id() == 'clang'
+ header_c_suppressions += [
+ '-Wno-nullability-extension',
+ ]
+endif
+
+header_c_suppressions = cc.get_supported_arguments(header_c_suppressions)
+
+test(
+ 'headers',
+ executable(
+ 'test_headers',
+ files('test_headers.c'),
+ c_args: header_c_suppressions,
+ dependencies: [lv2_dep],
+ implicit_include_directories: false,
+ ),
+ suite: 'unit',
+)
diff --git a/test/headers/test_headers.c b/test/headers/test_headers.c
new file mode 100644
index 0000000..d62b000
--- /dev/null
+++ b/test/headers/test_headers.c
@@ -0,0 +1,42 @@
+// Copyright 2022 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#include <lv2/atom/atom.h> // IWYU pragma: keep
+#include <lv2/atom/forge.h> // IWYU pragma: keep
+#include <lv2/atom/util.h> // IWYU pragma: keep
+#include <lv2/buf-size/buf-size.h> // IWYU pragma: keep
+#include <lv2/core/attributes.h> // IWYU pragma: keep
+#include <lv2/core/lv2.h> // IWYU pragma: keep
+#include <lv2/core/lv2_util.h> // IWYU pragma: keep
+#include <lv2/data-access/data-access.h> // IWYU pragma: keep
+#include <lv2/dynmanifest/dynmanifest.h> // IWYU pragma: keep
+#include <lv2/event/event-helpers.h> // IWYU pragma: keep
+#include <lv2/event/event.h> // IWYU pragma: keep
+#include <lv2/instance-access/instance-access.h> // IWYU pragma: keep
+#include <lv2/log/log.h> // IWYU pragma: keep
+#include <lv2/log/logger.h> // IWYU pragma: keep
+#include <lv2/midi/midi.h> // IWYU pragma: keep
+#include <lv2/morph/morph.h> // IWYU pragma: keep
+#include <lv2/options/options.h> // IWYU pragma: keep
+#include <lv2/parameters/parameters.h> // IWYU pragma: keep
+#include <lv2/patch/patch.h> // IWYU pragma: keep
+#include <lv2/port-groups/port-groups.h> // IWYU pragma: keep
+#include <lv2/port-props/port-props.h> // IWYU pragma: keep
+#include <lv2/presets/presets.h> // IWYU pragma: keep
+#include <lv2/resize-port/resize-port.h> // IWYU pragma: keep
+#include <lv2/state/state.h> // IWYU pragma: keep
+#include <lv2/time/time.h> // IWYU pragma: keep
+#include <lv2/ui/ui.h> // IWYU pragma: keep
+#include <lv2/units/units.h> // IWYU pragma: keep
+#include <lv2/uri-map/uri-map.h> // IWYU pragma: keep
+#include <lv2/urid/urid.h> // IWYU pragma: keep
+#include <lv2/worker/worker.h> // IWYU pragma: keep
+
+#ifdef __GNUC__
+__attribute__((const))
+#endif
+int
+main(void)
+{
+ return 0;
+}
diff --git a/test/meson.build b/test/meson.build
new file mode 100644
index 0000000..cddb05a
--- /dev/null
+++ b/test/meson.build
@@ -0,0 +1,180 @@
+# Copyright 2022 David Robillard <d@drobilla.net>
+# SPDX-License-Identifier: 0BSD OR ISC
+
+########
+# Data #
+########
+
+if get_option('lint')
+ # Check for spelling errors
+ codespell = find_program('codespell', required: get_option('tests'))
+ if codespell.found()
+ ignore = [
+ lv2_source_root / 'doc' / 'style' / 'pygments.css',
+ lv2_source_root / 'lv2specgen' / 'DTD',
+ lv2_source_root / 'schemas.lv2' / 'doap.ttl',
+ ]
+
+ test(
+ 'codespell',
+ codespell,
+ args: [
+ '-d',
+ ['-q', '3'],
+ ['-S', ','.join(ignore)],
+ lv2_source_root / 'doc',
+ lv2_source_root / 'lv2',
+ lv2_source_root / 'lv2specgen',
+ lv2_source_root / 'plugins',
+ lv2_source_root / 'schemas.lv2',
+ ],
+ suite: 'data',
+ )
+ endif
+
+ # Check that specification data is strictly formatted
+ serdi = find_program(
+ 'serdi',
+ required: get_option('tests'),
+ version: '>= 0.32.0',
+ )
+ native_build = (
+ not meson.is_cross_build()
+ and host_machine.system() != 'windows'
+ )
+ if serdi.found() and native_build
+ lv2_check_syntax = files(
+ lv2_source_root / 'scripts' / 'lv2_check_syntax.py',
+ )
+
+ test(
+ 'syntax',
+ lv2_check_syntax,
+ args: ['--serdi', serdi.full_path()] + spec_files + schema_data,
+ suite: 'data',
+ )
+ endif
+
+ # Check that specification data validates
+ sord_validate = find_program('sord_validate', required: get_option('tests'))
+ if sord_validate.found()
+ test('valid', sord_validate, args: spec_files + schema_data, suite: 'data')
+ endif
+endif
+
+########
+# Code #
+########
+
+# Check that all the headers compile cleanly in C
+test(
+ 'c',
+ executable(
+ 'test_build_c',
+ files('test_build.c'),
+ c_args: c_suppressions,
+ dependencies: [lv2_dep],
+ implicit_include_directories: false,
+ ),
+ suite: 'build',
+)
+
+# Check that all the headers compile cleanly in C++
+if is_variable('cpp')
+ test(
+ 'cpp',
+ executable(
+ 'test_build_cpp',
+ files('cpp/test_build.cpp'),
+ cpp_args: cpp_suppressions,
+ dependencies: [lv2_dep],
+ implicit_include_directories: false,
+ ),
+ suite: 'build',
+ )
+endif
+
+##########
+# Python #
+##########
+
+if get_option('lint')
+ # Scripts that don't pass with pylint
+ lax_python_scripts = files(
+ '../lv2specgen/lv2docgen.py',
+ '../lv2specgen/lv2specgen.py',
+ )
+
+ # Scripts that pass with everything including pylint
+ strict_python_scripts = lv2_scripts + files('../plugins/literasc.py')
+
+ all_python_scripts = lax_python_scripts + strict_python_scripts
+
+ # Check script formatting
+ black = find_program('black', required: get_option('tests'))
+ if black.found()
+ black_opts = ['-l', '79', '-q', '--check']
+ test(
+ 'black',
+ black,
+ args: black_opts + all_python_scripts,
+ suite: 'scripts',
+ )
+ endif
+
+ # Check scripts for errors with flake8
+ flake8 = find_program('flake8', required: get_option('tests'))
+ if flake8.found()
+ test('flake8', flake8, args: all_python_scripts, suite: 'scripts')
+ endif
+
+ # Check scripts for errors with pylint
+ pylint = find_program('pylint', required: get_option('tests'))
+ if pylint.found()
+ pymod = import('python')
+ lint_py = pymod.find_installation(
+ 'python3',
+ modules: ['pygments', 'rdflib'],
+ required: false,
+ )
+
+ if lint_py.found()
+ test('pylint', pylint, args: strict_python_scripts, suite: 'scripts')
+ endif
+ endif
+endif
+
+###################
+# Header Warnings #
+###################
+
+subdir('headers')
+
+##############
+# Unit Tests #
+##############
+
+test_names = [
+ 'atom',
+ 'forge_overflow',
+]
+
+atom_test_suppressions = []
+if cc.get_id() == 'gcc'
+ atom_test_suppressions += ['-Wno-stringop-overflow']
+endif
+
+# Build and run tests
+foreach test_name : test_names
+ test(
+ test_name,
+ executable(
+ test_name,
+ files('test_@0@.c'.format(test_name)),
+ c_args: c_suppressions + atom_test_suppressions,
+ dependencies: [lv2_dep],
+ implicit_include_directories: false,
+ ),
+ suite: 'unit',
+ )
+endforeach
diff --git a/test/test_atom.c b/test/test_atom.c
new file mode 100644
index 0000000..f88c4c7
--- /dev/null
+++ b/test/test_atom.c
@@ -0,0 +1,354 @@
+// Copyright 2012-2015 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#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*)&path[1];
+ 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*)&uri[1];
+ 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*)&string[1];
+ 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*)&literal[1];
+ 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));
+ const void* vec_body = LV2_ATOM_CONTENTS_CONST(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_build.c b/test/test_build.c
new file mode 100644
index 0000000..83a69df
--- /dev/null
+++ b/test/test_build.c
@@ -0,0 +1,39 @@
+// Copyright 2022 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#include <lv2/atom/atom.h> // IWYU pragma: keep
+#include <lv2/atom/forge.h> // IWYU pragma: keep
+#include <lv2/atom/util.h> // IWYU pragma: keep
+#include <lv2/buf-size/buf-size.h> // IWYU pragma: keep
+#include <lv2/core/attributes.h> // IWYU pragma: keep
+#include <lv2/core/lv2.h> // IWYU pragma: keep
+#include <lv2/core/lv2_util.h> // IWYU pragma: keep
+#include <lv2/data-access/data-access.h> // IWYU pragma: keep
+#include <lv2/dynmanifest/dynmanifest.h> // IWYU pragma: keep
+#include <lv2/event/event-helpers.h> // IWYU pragma: keep
+#include <lv2/event/event.h> // IWYU pragma: keep
+#include <lv2/instance-access/instance-access.h> // IWYU pragma: keep
+#include <lv2/log/log.h> // IWYU pragma: keep
+#include <lv2/log/logger.h> // IWYU pragma: keep
+#include <lv2/midi/midi.h> // IWYU pragma: keep
+#include <lv2/morph/morph.h> // IWYU pragma: keep
+#include <lv2/options/options.h> // IWYU pragma: keep
+#include <lv2/parameters/parameters.h> // IWYU pragma: keep
+#include <lv2/patch/patch.h> // IWYU pragma: keep
+#include <lv2/port-groups/port-groups.h> // IWYU pragma: keep
+#include <lv2/port-props/port-props.h> // IWYU pragma: keep
+#include <lv2/presets/presets.h> // IWYU pragma: keep
+#include <lv2/resize-port/resize-port.h> // IWYU pragma: keep
+#include <lv2/state/state.h> // IWYU pragma: keep
+#include <lv2/time/time.h> // IWYU pragma: keep
+#include <lv2/ui/ui.h> // IWYU pragma: keep
+#include <lv2/units/units.h> // IWYU pragma: keep
+#include <lv2/uri-map/uri-map.h> // IWYU pragma: keep
+#include <lv2/urid/urid.h> // IWYU pragma: keep
+#include <lv2/worker/worker.h> // IWYU pragma: keep
+
+int
+main(void)
+{
+ return 0;
+}
diff --git a/test/test_forge_overflow.c b/test/test_forge_overflow.c
new file mode 100644
index 0000000..7e97ae4
--- /dev/null
+++ b/test/test_forge_overflow.c
@@ -0,0 +1,223 @@
+// Copyright 2019 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#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;
+}
generated by cgit v1.2.1 (git 2.18.0) at 2025-07-02 04:53:31 +0000