build_sources_program test-type_array-fll_ids_adjust.c test-type_array-fll_ids_append.c test-type_array-fll_ids_decimate_by.c test-type_array-fll_ids_decrease_by.c test-type_array-fll_ids_increase.c test-type_array-fll_ids_increase_by.c test-type_array-fll_ids_resize.c
build_sources_program test-type_array-fll_idss_adjust.c test-type_array-fll_idss_append.c test-type_array-fll_idss_decimate_by.c test-type_array-fll_idss_decrease_by.c test-type_array-fll_idss_increase.c test-type_array-fll_idss_increase_by.c test-type_array-fll_idss_resize.c
build_sources_program test-type_array-cells_adjust.c test-type_array-cells_append.c test-type_array-cells_decimate_by.c test-type_array-cells_decrease_by.c test-type_array-cells_increase.c test-type_array-cells_increase_by.c test-type_array-cells_resize.c
+build_sources_program test-type_array-cellss_adjust.c test-type_array-cellss_append.c test-type_array-cellss_decimate_by.c test-type_array-cellss_decrease_by.c test-type_array-cellss_increase.c test-type_array-cellss_increase_by.c test-type_array-cellss_resize.c
+build_sources_program test-type_array-int8s_adjust.c test-type_array-int8s_append.c test-type_array-int8s_decimate_by.c test-type_array-int8s_decrease_by.c test-type_array-int8s_increase.c test-type_array-int8s_increase_by.c test-type_array-int8s_resize.c
+build_sources_program test-type_array-int8ss_adjust.c test-type_array-int8ss_append.c test-type_array-int8ss_decimate_by.c test-type_array-int8ss_decrease_by.c test-type_array-int8ss_increase.c test-type_array-int8ss_increase_by.c test-type_array-int8ss_resize.c
+build_sources_program test-type_array-int16s_adjust.c test-type_array-int16s_append.c test-type_array-int16s_decimate_by.c test-type_array-int16s_decrease_by.c test-type_array-int16s_increase.c test-type_array-int16s_increase_by.c test-type_array-int16s_resize.c
+build_sources_program test-type_array-int16ss_adjust.c test-type_array-int16ss_append.c test-type_array-int16ss_decimate_by.c test-type_array-int16ss_decrease_by.c test-type_array-int16ss_increase.c test-type_array-int16ss_increase_by.c test-type_array-int16ss_resize.c
+build_sources_program test-type_array-int32s_adjust.c test-type_array-int32s_append.c test-type_array-int32s_decimate_by.c test-type_array-int32s_decrease_by.c test-type_array-int32s_increase.c test-type_array-int32s_increase_by.c test-type_array-int32s_resize.c
+build_sources_program test-type_array-int32ss_adjust.c test-type_array-int32ss_append.c test-type_array-int32ss_decimate_by.c test-type_array-int32ss_decrease_by.c test-type_array-int32ss_increase.c test-type_array-int32ss_increase_by.c test-type_array-int32ss_resize.c
+build_sources_program test-type_array-int64s_adjust.c test-type_array-int64s_append.c test-type_array-int64s_decimate_by.c test-type_array-int64s_decrease_by.c test-type_array-int64s_increase.c test-type_array-int64s_increase_by.c test-type_array-int64s_resize.c
+build_sources_program test-type_array-int64ss_adjust.c test-type_array-int64ss_append.c test-type_array-int64ss_decimate_by.c test-type_array-int64ss_decrease_by.c test-type_array-int64ss_increase.c test-type_array-int64ss_increase_by.c test-type_array-int64ss_resize.c
+build_sources_program test-type_array-int128s_adjust.c test-type_array-int128s_append.c test-type_array-int128s_decimate_by.c test-type_array-int128s_decrease_by.c test-type_array-int128s_increase.c test-type_array-int128s_increase_by.c test-type_array-int128s_resize.c
+build_sources_program test-type_array-int128ss_adjust.c test-type_array-int128ss_append.c test-type_array-int128ss_decimate_by.c test-type_array-int128ss_decrease_by.c test-type_array-int128ss_increase.c test-type_array-int128ss_increase_by.c test-type_array-int128ss_resize.c
build_sources_program test-type_array-states_adjust.c test-type_array-states_append.c test-type_array-states_decimate_by.c test-type_array-states_decrease_by.c test-type_array-states_increase.c test-type_array-states_increase_by.c test-type_array-states_resize.c
build_sources_program test-type_array-statess_adjust.c test-type_array-statess_append.c test-type_array-statess_decimate_by.c test-type_array-statess_decrease_by.c test-type_array-statess_increase.c test-type_array-statess_increase_by.c test-type_array-statess_resize.c
-build_sources_program test-type_array-cellss_adjust.c test-type_array-cellss_append.c test-type_array-cellss_decimate_by.c test-type_array-cellss_decrease_by.c test-type_array-cellss_increase.c test-type_array-cellss_increase_by.c test-type_array-cellss_resize.c
build_sources_program test-type_array-statuss_adjust.c test-type_array-statuss_append.c test-type_array-statuss_decimate_by.c test-type_array-statuss_decrease_by.c test-type_array-statuss_increase.c test-type_array-statuss_increase_by.c test-type_array-statuss_resize.c
build_sources_program test-type_array-statusss_adjust.c test-type_array-statusss_append.c test-type_array-statusss_decimate_by.c test-type_array-statusss_decrease_by.c test-type_array-statusss_increase.c test-type_array-statusss_increase_by.c test-type_array-statusss_resize.c
+build_sources_program test-type_array-uint8s_adjust.c test-type_array-uint8s_append.c test-type_array-uint8s_decimate_by.c test-type_array-uint8s_decrease_by.c test-type_array-uint8s_increase.c test-type_array-uint8s_increase_by.c test-type_array-uint8s_resize.c
+build_sources_program test-type_array-uint8ss_adjust.c test-type_array-uint8ss_append.c test-type_array-uint8ss_decimate_by.c test-type_array-uint8ss_decrease_by.c test-type_array-uint8ss_increase.c test-type_array-uint8ss_increase_by.c test-type_array-uint8ss_resize.c
+build_sources_program test-type_array-uint16s_adjust.c test-type_array-uint16s_append.c test-type_array-uint16s_decimate_by.c test-type_array-uint16s_decrease_by.c test-type_array-uint16s_increase.c test-type_array-uint16s_increase_by.c test-type_array-uint16s_resize.c
+build_sources_program test-type_array-uint16ss_adjust.c test-type_array-uint16ss_append.c test-type_array-uint16ss_decimate_by.c test-type_array-uint16ss_decrease_by.c test-type_array-uint16ss_increase.c test-type_array-uint16ss_increase_by.c test-type_array-uint16ss_resize.c
+build_sources_program test-type_array-uint32s_adjust.c test-type_array-uint32s_append.c test-type_array-uint32s_decimate_by.c test-type_array-uint32s_decrease_by.c test-type_array-uint32s_increase.c test-type_array-uint32s_increase_by.c test-type_array-uint32s_resize.c
+build_sources_program test-type_array-uint32ss_adjust.c test-type_array-uint32ss_append.c test-type_array-uint32ss_decimate_by.c test-type_array-uint32ss_decrease_by.c test-type_array-uint32ss_increase.c test-type_array-uint32ss_increase_by.c test-type_array-uint32ss_resize.c
+build_sources_program test-type_array-uint64s_adjust.c test-type_array-uint64s_append.c test-type_array-uint64s_decimate_by.c test-type_array-uint64s_decrease_by.c test-type_array-uint64s_increase.c test-type_array-uint64s_increase_by.c test-type_array-uint64s_resize.c
+build_sources_program test-type_array-uint64ss_adjust.c test-type_array-uint64ss_append.c test-type_array-uint64ss_decimate_by.c test-type_array-uint64ss_decrease_by.c test-type_array-uint64ss_increase.c test-type_array-uint64ss_increase_by.c test-type_array-uint64ss_resize.c
+build_sources_program test-type_array-uint128s_adjust.c test-type_array-uint128s_append.c test-type_array-uint128s_decimate_by.c test-type_array-uint128s_decrease_by.c test-type_array-uint128s_increase.c test-type_array-uint128s_increase_by.c test-type_array-uint128s_resize.c
+build_sources_program test-type_array-uint128ss_adjust.c test-type_array-uint128ss_append.c test-type_array-uint128ss_decimate_by.c test-type_array-uint128ss_decrease_by.c test-type_array-uint128ss_increase.c test-type_array-uint128ss_increase_by.c test-type_array-uint128ss_resize.c
build_sources_program test-type_array.c
build_script no
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_adjust
+#define _TEST__F_type_array__int128s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_adjust()
+ */
+extern void test__f_type_array_int128s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_adjust()
+ */
+extern void test__f_type_array_int128s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_int128s_t source = f_int128s_t_initialize;
+ f_int128s_t destination = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_int128s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int128s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128s_t source = f_int128s_t_initialize;
+ f_int128s_t destination = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int128s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_append
+#define _TEST__F_type_array__int128s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_append()
+ */
+extern void test__f_type_array_int128s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int128s_append()
+ */
+extern void test__f_type_array_int128s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_append()
+ */
+extern void test__f_type_array_int128s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int128s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_decimate_by
+#define _TEST__F_type_array__int128s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_decimate_by()
+ */
+extern void test__f_type_array_int128s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_decimate_by()
+ */
+extern void test__f_type_array_int128s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int128s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_decrease_by
+#define _TEST__F_type_array__int128s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_decrease_by()
+ */
+extern void test__f_type_array_int128s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_decrease_by()
+ */
+extern void test__f_type_array_int128s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_increase__works(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int128s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_increase
+#define _TEST__F_type_array__int128s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_increase()
+ */
+extern void test__f_type_array_int128s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int128s_increase()
+ */
+extern void test__f_type_array_int128s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_increase()
+ */
+extern void test__f_type_array_int128s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int128s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_increase_by
+#define _TEST__F_type_array__int128s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_increase_by()
+ */
+extern void test__f_type_array_int128s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_increase_by()
+ */
+extern void test__f_type_array_int128s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128s_resize__works(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128s_resize
+#define _TEST__F_type_array__int128s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128s_resize()
+ */
+extern void test__f_type_array_int128s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128s_resize()
+ */
+extern void test__f_type_array_int128s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128ss_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128ss_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_adjust
+#define _TEST__F_type_array__int128ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_adjust()
+ */
+extern void test__f_type_array_int128ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_adjust()
+ */
+extern void test__f_type_array_int128ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_int128ss_t source = f_int128s_t_initialize;
+ f_int128ss_t destination = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_int128s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_int128ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int128ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128ss_t source = f_int128s_t_initialize;
+ f_int128ss_t destination = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int128ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_append
+#define _TEST__F_type_array__int128ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_append()
+ */
+extern void test__f_type_array_int128ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int128ss_append()
+ */
+extern void test__f_type_array_int128ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_append()
+ */
+extern void test__f_type_array_int128ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int128ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_decimate_by
+#define _TEST__F_type_array__int128ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_decimate_by()
+ */
+extern void test__f_type_array_int128ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_decimate_by()
+ */
+extern void test__f_type_array_int128ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int128ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_decrease_by
+#define _TEST__F_type_array__int128ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_decrease_by()
+ */
+extern void test__f_type_array_int128ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_decrease_by()
+ */
+extern void test__f_type_array_int128ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int128ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_increase
+#define _TEST__F_type_array__int128ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_increase()
+ */
+extern void test__f_type_array_int128ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int128ss_increase()
+ */
+extern void test__f_type_array_int128ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_increase()
+ */
+extern void test__f_type_array_int128ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int128ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_increase_by
+#define _TEST__F_type_array__int128ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_increase_by()
+ */
+extern void test__f_type_array_int128ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_increase_by()
+ */
+extern void test__f_type_array_int128ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int128ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int128ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128ss_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int128ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int128ss_t data = f_int128ss_t_initialize;
+
+ {
+ const f_status_t status = f_int128ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int128ss_resize
+#define _TEST__F_type_array__int128ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int128ss_resize()
+ */
+extern void test__f_type_array_int128ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int128ss_resize()
+ */
+extern void test__f_type_array_int128ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int128ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_adjust
+#define _TEST__F_type_array__int16s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_adjust()
+ */
+extern void test__f_type_array_int16s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_adjust()
+ */
+extern void test__f_type_array_int16s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_int16s_t source = f_int16s_t_initialize;
+ f_int16s_t destination = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_int16s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int16s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16s_t source = f_int16s_t_initialize;
+ f_int16s_t destination = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int16s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_append
+#define _TEST__F_type_array__int16s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_append()
+ */
+extern void test__f_type_array_int16s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int16s_append()
+ */
+extern void test__f_type_array_int16s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_append()
+ */
+extern void test__f_type_array_int16s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int16s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_decimate_by
+#define _TEST__F_type_array__int16s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_decimate_by()
+ */
+extern void test__f_type_array_int16s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_decimate_by()
+ */
+extern void test__f_type_array_int16s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int16s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_decrease_by
+#define _TEST__F_type_array__int16s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_decrease_by()
+ */
+extern void test__f_type_array_int16s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_decrease_by()
+ */
+extern void test__f_type_array_int16s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_increase__works(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int16s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_increase
+#define _TEST__F_type_array__int16s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_increase()
+ */
+extern void test__f_type_array_int16s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int16s_increase()
+ */
+extern void test__f_type_array_int16s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_increase()
+ */
+extern void test__f_type_array_int16s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int16s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_increase_by
+#define _TEST__F_type_array__int16s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_increase_by()
+ */
+extern void test__f_type_array_int16s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_increase_by()
+ */
+extern void test__f_type_array_int16s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16s_resize__works(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16s_resize
+#define _TEST__F_type_array__int16s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16s_resize()
+ */
+extern void test__f_type_array_int16s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16s_resize()
+ */
+extern void test__f_type_array_int16s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16ss_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16ss_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_adjust
+#define _TEST__F_type_array__int16ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_adjust()
+ */
+extern void test__f_type_array_int16ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_adjust()
+ */
+extern void test__f_type_array_int16ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_int16ss_t source = f_int16s_t_initialize;
+ f_int16ss_t destination = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_int16s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_int16ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int16ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16ss_t source = f_int16s_t_initialize;
+ f_int16ss_t destination = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int16ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_append
+#define _TEST__F_type_array__int16ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_append()
+ */
+extern void test__f_type_array_int16ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int16ss_append()
+ */
+extern void test__f_type_array_int16ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_append()
+ */
+extern void test__f_type_array_int16ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int16ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_decimate_by
+#define _TEST__F_type_array__int16ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_decimate_by()
+ */
+extern void test__f_type_array_int16ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_decimate_by()
+ */
+extern void test__f_type_array_int16ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int16ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_decrease_by
+#define _TEST__F_type_array__int16ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_decrease_by()
+ */
+extern void test__f_type_array_int16ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_decrease_by()
+ */
+extern void test__f_type_array_int16ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int16ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_increase
+#define _TEST__F_type_array__int16ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_increase()
+ */
+extern void test__f_type_array_int16ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int16ss_increase()
+ */
+extern void test__f_type_array_int16ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_increase()
+ */
+extern void test__f_type_array_int16ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int16ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_increase_by
+#define _TEST__F_type_array__int16ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_increase_by()
+ */
+extern void test__f_type_array_int16ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_increase_by()
+ */
+extern void test__f_type_array_int16ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int16ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int16ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16ss_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int16ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int16ss_t data = f_int16ss_t_initialize;
+
+ {
+ const f_status_t status = f_int16ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int16ss_resize
+#define _TEST__F_type_array__int16ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int16ss_resize()
+ */
+extern void test__f_type_array_int16ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int16ss_resize()
+ */
+extern void test__f_type_array_int16ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int16ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_adjust
+#define _TEST__F_type_array__int32s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_adjust()
+ */
+extern void test__f_type_array_int32s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_adjust()
+ */
+extern void test__f_type_array_int32s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_int32s_t source = f_int32s_t_initialize;
+ f_int32s_t destination = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_int32s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int32s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32s_t source = f_int32s_t_initialize;
+ f_int32s_t destination = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int32s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_append
+#define _TEST__F_type_array__int32s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_append()
+ */
+extern void test__f_type_array_int32s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int32s_append()
+ */
+extern void test__f_type_array_int32s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_append()
+ */
+extern void test__f_type_array_int32s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int32s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_decimate_by
+#define _TEST__F_type_array__int32s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_decimate_by()
+ */
+extern void test__f_type_array_int32s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_decimate_by()
+ */
+extern void test__f_type_array_int32s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int32s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_decrease_by
+#define _TEST__F_type_array__int32s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_decrease_by()
+ */
+extern void test__f_type_array_int32s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_decrease_by()
+ */
+extern void test__f_type_array_int32s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_increase__works(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int32s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_increase
+#define _TEST__F_type_array__int32s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_increase()
+ */
+extern void test__f_type_array_int32s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int32s_increase()
+ */
+extern void test__f_type_array_int32s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_increase()
+ */
+extern void test__f_type_array_int32s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int32s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_increase_by
+#define _TEST__F_type_array__int32s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_increase_by()
+ */
+extern void test__f_type_array_int32s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_increase_by()
+ */
+extern void test__f_type_array_int32s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32s_resize__works(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32s_resize
+#define _TEST__F_type_array__int32s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32s_resize()
+ */
+extern void test__f_type_array_int32s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32s_resize()
+ */
+extern void test__f_type_array_int32s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32ss_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32ss_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_adjust
+#define _TEST__F_type_array__int32ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_adjust()
+ */
+extern void test__f_type_array_int32ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_adjust()
+ */
+extern void test__f_type_array_int32ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_int32ss_t source = f_int32s_t_initialize;
+ f_int32ss_t destination = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_int32s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_int32ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int32ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32ss_t source = f_int32s_t_initialize;
+ f_int32ss_t destination = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int32ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_append
+#define _TEST__F_type_array__int32ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_append()
+ */
+extern void test__f_type_array_int32ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int32ss_append()
+ */
+extern void test__f_type_array_int32ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_append()
+ */
+extern void test__f_type_array_int32ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int32ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_decimate_by
+#define _TEST__F_type_array__int32ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_decimate_by()
+ */
+extern void test__f_type_array_int32ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_decimate_by()
+ */
+extern void test__f_type_array_int32ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int32ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_decrease_by
+#define _TEST__F_type_array__int32ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_decrease_by()
+ */
+extern void test__f_type_array_int32ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_decrease_by()
+ */
+extern void test__f_type_array_int32ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int32ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_increase
+#define _TEST__F_type_array__int32ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_increase()
+ */
+extern void test__f_type_array_int32ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int32ss_increase()
+ */
+extern void test__f_type_array_int32ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_increase()
+ */
+extern void test__f_type_array_int32ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int32ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_increase_by
+#define _TEST__F_type_array__int32ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_increase_by()
+ */
+extern void test__f_type_array_int32ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_increase_by()
+ */
+extern void test__f_type_array_int32ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int32ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int32ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32ss_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int32ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int32ss_t data = f_int32ss_t_initialize;
+
+ {
+ const f_status_t status = f_int32ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int32ss_resize
+#define _TEST__F_type_array__int32ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int32ss_resize()
+ */
+extern void test__f_type_array_int32ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int32ss_resize()
+ */
+extern void test__f_type_array_int32ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int32ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_adjust
+#define _TEST__F_type_array__int64s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_adjust()
+ */
+extern void test__f_type_array_int64s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_adjust()
+ */
+extern void test__f_type_array_int64s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_int64s_t source = f_int64s_t_initialize;
+ f_int64s_t destination = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_int64s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int64s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64s_t source = f_int64s_t_initialize;
+ f_int64s_t destination = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int64s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_append
+#define _TEST__F_type_array__int64s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_append()
+ */
+extern void test__f_type_array_int64s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int64s_append()
+ */
+extern void test__f_type_array_int64s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_append()
+ */
+extern void test__f_type_array_int64s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int64s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_decimate_by
+#define _TEST__F_type_array__int64s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_decimate_by()
+ */
+extern void test__f_type_array_int64s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_decimate_by()
+ */
+extern void test__f_type_array_int64s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int64s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_decrease_by
+#define _TEST__F_type_array__int64s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_decrease_by()
+ */
+extern void test__f_type_array_int64s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_decrease_by()
+ */
+extern void test__f_type_array_int64s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_increase__works(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int64s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_increase
+#define _TEST__F_type_array__int64s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_increase()
+ */
+extern void test__f_type_array_int64s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int64s_increase()
+ */
+extern void test__f_type_array_int64s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_increase()
+ */
+extern void test__f_type_array_int64s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int64s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_increase_by
+#define _TEST__F_type_array__int64s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_increase_by()
+ */
+extern void test__f_type_array_int64s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_increase_by()
+ */
+extern void test__f_type_array_int64s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64s_resize__works(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64s_resize
+#define _TEST__F_type_array__int64s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64s_resize()
+ */
+extern void test__f_type_array_int64s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64s_resize()
+ */
+extern void test__f_type_array_int64s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64ss_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64ss_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_adjust
+#define _TEST__F_type_array__int64ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_adjust()
+ */
+extern void test__f_type_array_int64ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_adjust()
+ */
+extern void test__f_type_array_int64ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_int64ss_t source = f_int64s_t_initialize;
+ f_int64ss_t destination = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_int64s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_int64ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int64ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64ss_t source = f_int64s_t_initialize;
+ f_int64ss_t destination = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int64ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_append
+#define _TEST__F_type_array__int64ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_append()
+ */
+extern void test__f_type_array_int64ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int64ss_append()
+ */
+extern void test__f_type_array_int64ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_append()
+ */
+extern void test__f_type_array_int64ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int64ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_decimate_by
+#define _TEST__F_type_array__int64ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_decimate_by()
+ */
+extern void test__f_type_array_int64ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_decimate_by()
+ */
+extern void test__f_type_array_int64ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int64ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_decrease_by
+#define _TEST__F_type_array__int64ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_decrease_by()
+ */
+extern void test__f_type_array_int64ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_decrease_by()
+ */
+extern void test__f_type_array_int64ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int64ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_increase
+#define _TEST__F_type_array__int64ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_increase()
+ */
+extern void test__f_type_array_int64ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int64ss_increase()
+ */
+extern void test__f_type_array_int64ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_increase()
+ */
+extern void test__f_type_array_int64ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int64ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_increase_by
+#define _TEST__F_type_array__int64ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_increase_by()
+ */
+extern void test__f_type_array_int64ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_increase_by()
+ */
+extern void test__f_type_array_int64ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int64ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int64ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64ss_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int64ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int64ss_t data = f_int64ss_t_initialize;
+
+ {
+ const f_status_t status = f_int64ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int64ss_resize
+#define _TEST__F_type_array__int64ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int64ss_resize()
+ */
+extern void test__f_type_array_int64ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int64ss_resize()
+ */
+extern void test__f_type_array_int64ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int64ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_adjust
+#define _TEST__F_type_array__int8s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_adjust()
+ */
+extern void test__f_type_array_int8s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_adjust()
+ */
+extern void test__f_type_array_int8s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_int8s_t source = f_int8s_t_initialize;
+ f_int8s_t destination = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_int8s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int8s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8s_t source = f_int8s_t_initialize;
+ f_int8s_t destination = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int8s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_append
+#define _TEST__F_type_array__int8s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_append()
+ */
+extern void test__f_type_array_int8s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int8s_append()
+ */
+extern void test__f_type_array_int8s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_append()
+ */
+extern void test__f_type_array_int8s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int8s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_decimate_by
+#define _TEST__F_type_array__int8s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_decimate_by()
+ */
+extern void test__f_type_array_int8s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_decimate_by()
+ */
+extern void test__f_type_array_int8s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int8s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_decrease_by
+#define _TEST__F_type_array__int8s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_decrease_by()
+ */
+extern void test__f_type_array_int8s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_decrease_by()
+ */
+extern void test__f_type_array_int8s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_increase__works(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int8s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_increase
+#define _TEST__F_type_array__int8s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_increase()
+ */
+extern void test__f_type_array_int8s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int8s_increase()
+ */
+extern void test__f_type_array_int8s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_increase()
+ */
+extern void test__f_type_array_int8s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int8s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_increase_by
+#define _TEST__F_type_array__int8s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_increase_by()
+ */
+extern void test__f_type_array_int8s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_increase_by()
+ */
+extern void test__f_type_array_int8s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8s_resize__works(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8s_resize
+#define _TEST__F_type_array__int8s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8s_resize()
+ */
+extern void test__f_type_array_int8s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8s_resize()
+ */
+extern void test__f_type_array_int8s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8ss_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8ss_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_adjust
+#define _TEST__F_type_array__int8ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_adjust()
+ */
+extern void test__f_type_array_int8ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_adjust()
+ */
+extern void test__f_type_array_int8ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_int8ss_t source = f_int8s_t_initialize;
+ f_int8ss_t destination = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_int8s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_int8ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_int8ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8ss_t source = f_int8s_t_initialize;
+ f_int8ss_t destination = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_int8ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_append
+#define _TEST__F_type_array__int8ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_append()
+ */
+extern void test__f_type_array_int8ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int8ss_append()
+ */
+extern void test__f_type_array_int8ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_append()
+ */
+extern void test__f_type_array_int8ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int8ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_decimate_by
+#define _TEST__F_type_array__int8ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_decimate_by()
+ */
+extern void test__f_type_array_int8ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_decimate_by()
+ */
+extern void test__f_type_array_int8ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_int8ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_decrease_by
+#define _TEST__F_type_array__int8ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_decrease_by()
+ */
+extern void test__f_type_array_int8ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_decrease_by()
+ */
+extern void test__f_type_array_int8ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int8ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_increase
+#define _TEST__F_type_array__int8ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_increase()
+ */
+extern void test__f_type_array_int8ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_int8ss_increase()
+ */
+extern void test__f_type_array_int8ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_increase()
+ */
+extern void test__f_type_array_int8ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_int8ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_increase_by
+#define _TEST__F_type_array__int8ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_increase_by()
+ */
+extern void test__f_type_array_int8ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_increase_by()
+ */
+extern void test__f_type_array_int8ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-int8ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_int8ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8ss_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_int8ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_int8ss_t data = f_int8ss_t_initialize;
+
+ {
+ const f_status_t status = f_int8ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__int8ss_resize
+#define _TEST__F_type_array__int8ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_int8ss_resize()
+ */
+extern void test__f_type_array_int8ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_int8ss_resize()
+ */
+extern void test__f_type_array_int8ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__int8ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_adjust
+#define _TEST__F_type_array__uint128s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_adjust()
+ */
+extern void test__f_type_array_uint128s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_adjust()
+ */
+extern void test__f_type_array_uint128s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_uint128s_t source = f_uint128s_t_initialize;
+ f_uint128s_t destination = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_uint128s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint128s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128s_t source = f_uint128s_t_initialize;
+ f_uint128s_t destination = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint128s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_append
+#define _TEST__F_type_array__uint128s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_append()
+ */
+extern void test__f_type_array_uint128s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint128s_append()
+ */
+extern void test__f_type_array_uint128s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_append()
+ */
+extern void test__f_type_array_uint128s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint128s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_decimate_by
+#define _TEST__F_type_array__uint128s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_decimate_by()
+ */
+extern void test__f_type_array_uint128s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_decimate_by()
+ */
+extern void test__f_type_array_uint128s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint128s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_decrease_by
+#define _TEST__F_type_array__uint128s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_decrease_by()
+ */
+extern void test__f_type_array_uint128s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_decrease_by()
+ */
+extern void test__f_type_array_uint128s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint128s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_increase
+#define _TEST__F_type_array__uint128s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_increase()
+ */
+extern void test__f_type_array_uint128s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint128s_increase()
+ */
+extern void test__f_type_array_uint128s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_increase()
+ */
+extern void test__f_type_array_uint128s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint128s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_increase_by
+#define _TEST__F_type_array__uint128s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_increase_by()
+ */
+extern void test__f_type_array_uint128s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_increase_by()
+ */
+extern void test__f_type_array_uint128s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128s_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128s_resize
+#define _TEST__F_type_array__uint128s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128s_resize()
+ */
+extern void test__f_type_array_uint128s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128s_resize()
+ */
+extern void test__f_type_array_uint128s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_adjust
+#define _TEST__F_type_array__uint128ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_adjust()
+ */
+extern void test__f_type_array_uint128ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_adjust()
+ */
+extern void test__f_type_array_uint128ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_uint128ss_t source = f_uint128s_t_initialize;
+ f_uint128ss_t destination = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_uint128s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_uint128ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint128ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t source = f_uint128s_t_initialize;
+ f_uint128ss_t destination = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint128ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_append
+#define _TEST__F_type_array__uint128ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_append()
+ */
+extern void test__f_type_array_uint128ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint128ss_append()
+ */
+extern void test__f_type_array_uint128ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_append()
+ */
+extern void test__f_type_array_uint128ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint128ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_decimate_by
+#define _TEST__F_type_array__uint128ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_decimate_by()
+ */
+extern void test__f_type_array_uint128ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_decimate_by()
+ */
+extern void test__f_type_array_uint128ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint128ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_decrease_by
+#define _TEST__F_type_array__uint128ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_decrease_by()
+ */
+extern void test__f_type_array_uint128ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_decrease_by()
+ */
+extern void test__f_type_array_uint128ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint128ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_increase
+#define _TEST__F_type_array__uint128ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_increase()
+ */
+extern void test__f_type_array_uint128ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint128ss_increase()
+ */
+extern void test__f_type_array_uint128ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_increase()
+ */
+extern void test__f_type_array_uint128ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint128ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_increase_by
+#define _TEST__F_type_array__uint128ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_increase_by()
+ */
+extern void test__f_type_array_uint128ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_increase_by()
+ */
+extern void test__f_type_array_uint128ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint128ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint128ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint128ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint128ss_t data = f_uint128ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint128ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint128ss_resize
+#define _TEST__F_type_array__uint128ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint128ss_resize()
+ */
+extern void test__f_type_array_uint128ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint128ss_resize()
+ */
+extern void test__f_type_array_uint128ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint128ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_adjust
+#define _TEST__F_type_array__uint16s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_adjust()
+ */
+extern void test__f_type_array_uint16s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_adjust()
+ */
+extern void test__f_type_array_uint16s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_uint16s_t source = f_uint16s_t_initialize;
+ f_uint16s_t destination = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_uint16s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint16s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16s_t source = f_uint16s_t_initialize;
+ f_uint16s_t destination = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint16s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_append
+#define _TEST__F_type_array__uint16s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_append()
+ */
+extern void test__f_type_array_uint16s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint16s_append()
+ */
+extern void test__f_type_array_uint16s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_append()
+ */
+extern void test__f_type_array_uint16s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint16s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_decimate_by
+#define _TEST__F_type_array__uint16s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_decimate_by()
+ */
+extern void test__f_type_array_uint16s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_decimate_by()
+ */
+extern void test__f_type_array_uint16s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint16s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_decrease_by
+#define _TEST__F_type_array__uint16s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_decrease_by()
+ */
+extern void test__f_type_array_uint16s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_decrease_by()
+ */
+extern void test__f_type_array_uint16s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint16s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_increase
+#define _TEST__F_type_array__uint16s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_increase()
+ */
+extern void test__f_type_array_uint16s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint16s_increase()
+ */
+extern void test__f_type_array_uint16s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_increase()
+ */
+extern void test__f_type_array_uint16s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint16s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_increase_by
+#define _TEST__F_type_array__uint16s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_increase_by()
+ */
+extern void test__f_type_array_uint16s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_increase_by()
+ */
+extern void test__f_type_array_uint16s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16s_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16s_resize
+#define _TEST__F_type_array__uint16s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16s_resize()
+ */
+extern void test__f_type_array_uint16s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16s_resize()
+ */
+extern void test__f_type_array_uint16s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_adjust
+#define _TEST__F_type_array__uint16ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_adjust()
+ */
+extern void test__f_type_array_uint16ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_adjust()
+ */
+extern void test__f_type_array_uint16ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_uint16ss_t source = f_uint16s_t_initialize;
+ f_uint16ss_t destination = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_uint16s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_uint16ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint16ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t source = f_uint16s_t_initialize;
+ f_uint16ss_t destination = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint16ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_append
+#define _TEST__F_type_array__uint16ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_append()
+ */
+extern void test__f_type_array_uint16ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint16ss_append()
+ */
+extern void test__f_type_array_uint16ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_append()
+ */
+extern void test__f_type_array_uint16ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint16ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_decimate_by
+#define _TEST__F_type_array__uint16ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_decimate_by()
+ */
+extern void test__f_type_array_uint16ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_decimate_by()
+ */
+extern void test__f_type_array_uint16ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint16ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_decrease_by
+#define _TEST__F_type_array__uint16ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_decrease_by()
+ */
+extern void test__f_type_array_uint16ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_decrease_by()
+ */
+extern void test__f_type_array_uint16ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint16ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_increase
+#define _TEST__F_type_array__uint16ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_increase()
+ */
+extern void test__f_type_array_uint16ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint16ss_increase()
+ */
+extern void test__f_type_array_uint16ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_increase()
+ */
+extern void test__f_type_array_uint16ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint16ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_increase_by
+#define _TEST__F_type_array__uint16ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_increase_by()
+ */
+extern void test__f_type_array_uint16ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_increase_by()
+ */
+extern void test__f_type_array_uint16ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint16ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint16ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint16ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint16ss_t data = f_uint16ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint16ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint16ss_resize
+#define _TEST__F_type_array__uint16ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint16ss_resize()
+ */
+extern void test__f_type_array_uint16ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint16ss_resize()
+ */
+extern void test__f_type_array_uint16ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint16ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_adjust
+#define _TEST__F_type_array__uint32s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_adjust()
+ */
+extern void test__f_type_array_uint32s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_adjust()
+ */
+extern void test__f_type_array_uint32s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_uint32s_t source = f_uint32s_t_initialize;
+ f_uint32s_t destination = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_uint32s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint32s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32s_t source = f_uint32s_t_initialize;
+ f_uint32s_t destination = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint32s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_append
+#define _TEST__F_type_array__uint32s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_append()
+ */
+extern void test__f_type_array_uint32s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint32s_append()
+ */
+extern void test__f_type_array_uint32s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_append()
+ */
+extern void test__f_type_array_uint32s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint32s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_decimate_by
+#define _TEST__F_type_array__uint32s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_decimate_by()
+ */
+extern void test__f_type_array_uint32s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_decimate_by()
+ */
+extern void test__f_type_array_uint32s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint32s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_decrease_by
+#define _TEST__F_type_array__uint32s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_decrease_by()
+ */
+extern void test__f_type_array_uint32s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_decrease_by()
+ */
+extern void test__f_type_array_uint32s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint32s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_increase
+#define _TEST__F_type_array__uint32s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_increase()
+ */
+extern void test__f_type_array_uint32s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint32s_increase()
+ */
+extern void test__f_type_array_uint32s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_increase()
+ */
+extern void test__f_type_array_uint32s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint32s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_increase_by
+#define _TEST__F_type_array__uint32s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_increase_by()
+ */
+extern void test__f_type_array_uint32s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_increase_by()
+ */
+extern void test__f_type_array_uint32s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32s_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32s_resize
+#define _TEST__F_type_array__uint32s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32s_resize()
+ */
+extern void test__f_type_array_uint32s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32s_resize()
+ */
+extern void test__f_type_array_uint32s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_adjust
+#define _TEST__F_type_array__uint32ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_adjust()
+ */
+extern void test__f_type_array_uint32ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_adjust()
+ */
+extern void test__f_type_array_uint32ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_uint32ss_t source = f_uint32s_t_initialize;
+ f_uint32ss_t destination = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_uint32s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_uint32ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint32ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t source = f_uint32s_t_initialize;
+ f_uint32ss_t destination = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint32ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_append
+#define _TEST__F_type_array__uint32ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_append()
+ */
+extern void test__f_type_array_uint32ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint32ss_append()
+ */
+extern void test__f_type_array_uint32ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_append()
+ */
+extern void test__f_type_array_uint32ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint32ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_decimate_by
+#define _TEST__F_type_array__uint32ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_decimate_by()
+ */
+extern void test__f_type_array_uint32ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_decimate_by()
+ */
+extern void test__f_type_array_uint32ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint32ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_decrease_by
+#define _TEST__F_type_array__uint32ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_decrease_by()
+ */
+extern void test__f_type_array_uint32ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_decrease_by()
+ */
+extern void test__f_type_array_uint32ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint32ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_increase
+#define _TEST__F_type_array__uint32ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_increase()
+ */
+extern void test__f_type_array_uint32ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint32ss_increase()
+ */
+extern void test__f_type_array_uint32ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_increase()
+ */
+extern void test__f_type_array_uint32ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint32ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_increase_by
+#define _TEST__F_type_array__uint32ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_increase_by()
+ */
+extern void test__f_type_array_uint32ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_increase_by()
+ */
+extern void test__f_type_array_uint32ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint32ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint32ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint32ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint32ss_t data = f_uint32ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint32ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint32ss_resize
+#define _TEST__F_type_array__uint32ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint32ss_resize()
+ */
+extern void test__f_type_array_uint32ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint32ss_resize()
+ */
+extern void test__f_type_array_uint32ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint32ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_adjust
+#define _TEST__F_type_array__uint64s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_adjust()
+ */
+extern void test__f_type_array_uint64s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_adjust()
+ */
+extern void test__f_type_array_uint64s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_uint64s_t source = f_uint64s_t_initialize;
+ f_uint64s_t destination = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_uint64s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint64s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64s_t source = f_uint64s_t_initialize;
+ f_uint64s_t destination = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint64s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_append
+#define _TEST__F_type_array__uint64s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_append()
+ */
+extern void test__f_type_array_uint64s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint64s_append()
+ */
+extern void test__f_type_array_uint64s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_append()
+ */
+extern void test__f_type_array_uint64s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint64s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_decimate_by
+#define _TEST__F_type_array__uint64s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_decimate_by()
+ */
+extern void test__f_type_array_uint64s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_decimate_by()
+ */
+extern void test__f_type_array_uint64s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint64s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_decrease_by
+#define _TEST__F_type_array__uint64s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_decrease_by()
+ */
+extern void test__f_type_array_uint64s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_decrease_by()
+ */
+extern void test__f_type_array_uint64s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint64s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_increase
+#define _TEST__F_type_array__uint64s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_increase()
+ */
+extern void test__f_type_array_uint64s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint64s_increase()
+ */
+extern void test__f_type_array_uint64s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_increase()
+ */
+extern void test__f_type_array_uint64s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint64s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_increase_by
+#define _TEST__F_type_array__uint64s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_increase_by()
+ */
+extern void test__f_type_array_uint64s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_increase_by()
+ */
+extern void test__f_type_array_uint64s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64s_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64s_resize
+#define _TEST__F_type_array__uint64s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64s_resize()
+ */
+extern void test__f_type_array_uint64s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64s_resize()
+ */
+extern void test__f_type_array_uint64s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_adjust
+#define _TEST__F_type_array__uint64ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_adjust()
+ */
+extern void test__f_type_array_uint64ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_adjust()
+ */
+extern void test__f_type_array_uint64ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_uint64ss_t source = f_uint64s_t_initialize;
+ f_uint64ss_t destination = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_uint64s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_uint64ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint64ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t source = f_uint64s_t_initialize;
+ f_uint64ss_t destination = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint64ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_append
+#define _TEST__F_type_array__uint64ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_append()
+ */
+extern void test__f_type_array_uint64ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint64ss_append()
+ */
+extern void test__f_type_array_uint64ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_append()
+ */
+extern void test__f_type_array_uint64ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint64ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_decimate_by
+#define _TEST__F_type_array__uint64ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_decimate_by()
+ */
+extern void test__f_type_array_uint64ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_decimate_by()
+ */
+extern void test__f_type_array_uint64ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint64ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_decrease_by
+#define _TEST__F_type_array__uint64ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_decrease_by()
+ */
+extern void test__f_type_array_uint64ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_decrease_by()
+ */
+extern void test__f_type_array_uint64ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint64ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_increase
+#define _TEST__F_type_array__uint64ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_increase()
+ */
+extern void test__f_type_array_uint64ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint64ss_increase()
+ */
+extern void test__f_type_array_uint64ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_increase()
+ */
+extern void test__f_type_array_uint64ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint64ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_increase_by
+#define _TEST__F_type_array__uint64ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_increase_by()
+ */
+extern void test__f_type_array_uint64ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_increase_by()
+ */
+extern void test__f_type_array_uint64ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint64ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint64ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint64ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint64ss_t data = f_uint64ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint64ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint64ss_resize
+#define _TEST__F_type_array__uint64ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint64ss_resize()
+ */
+extern void test__f_type_array_uint64ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint64ss_resize()
+ */
+extern void test__f_type_array_uint64ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint64ss_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8s_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_adjust
+#define _TEST__F_type_array__uint8s_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_adjust()
+ */
+extern void test__f_type_array_uint8s_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_adjust()
+ */
+extern void test__f_type_array_uint8s_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_append__works(void **state) {
+
+ const int length = 5;
+ const int length_used = 2;
+ f_uint8s_t source = f_uint8s_t_initialize;
+ f_uint8s_t destination = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ for (; source.used < length_used; ++source.used) {
+ source.array[source.used] = source.used + 1;
+ } // for
+
+ {
+ const f_status_t status = f_uint8s_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ assert_int_equal(destination.array[i], i + 1);
+ } // for
+ }
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint8s_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8s_t source = f_uint8s_t_initialize;
+ f_uint8s_t destination = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint8s_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_append
+#define _TEST__F_type_array__uint8s_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_append()
+ */
+extern void test__f_type_array_uint8s_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint8s_append()
+ */
+extern void test__f_type_array_uint8s_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_append()
+ */
+extern void test__f_type_array_uint8s_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint8s_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_decimate_by
+#define _TEST__F_type_array__uint8s_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_decimate_by()
+ */
+extern void test__f_type_array_uint8s_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_decimate_by()
+ */
+extern void test__f_type_array_uint8s_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint8s_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_decrease_by
+#define _TEST__F_type_array__uint8s_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_decrease_by()
+ */
+extern void test__f_type_array_uint8s_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_decrease_by()
+ */
+extern void test__f_type_array_uint8s_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint8s_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8s_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8s_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_increase
+#define _TEST__F_type_array__uint8s_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_increase()
+ */
+extern void test__f_type_array_uint8s_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint8s_increase()
+ */
+extern void test__f_type_array_uint8s_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_increase()
+ */
+extern void test__f_type_array_uint8s_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint8s_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8s_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_increase_by
+#define _TEST__F_type_array__uint8s_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_increase_by()
+ */
+extern void test__f_type_array_uint8s_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_increase_by()
+ */
+extern void test__f_type_array_uint8s_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8s_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8s_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8s_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8s_resize
+#define _TEST__F_type_array__uint8s_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8s_resize()
+ */
+extern void test__f_type_array_uint8s_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8s_resize()
+ */
+extern void test__f_type_array_uint8s_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8s_resize
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_adjust.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_adjust__works(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_adjust(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8ss_adjust__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_adjust(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_adjust
+#define _TEST__F_type_array__uint8ss_adjust
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_adjust()
+ */
+extern void test__f_type_array_uint8ss_adjust__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_adjust()
+ */
+extern void test__f_type_array_uint8ss_adjust__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_adjust
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_append.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_append__works(void **state) {
+
+ const int length = 5;
+ const int length_inner = 2;
+ f_uint8ss_t source = f_uint8s_t_initialize;
+ f_uint8ss_t destination = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ for (; source.used < length; ++source.used) {
+
+ const f_status_t status = f_uint8s_resize(length_inner, &source.array[source.used]);
+
+ assert_int_equal(status, F_none);
+
+ for (f_array_length_t i = 0; i < length_inner; ++i) {
+ source.array[source.used].array[source.array[source.used].used++] = i + 1;
+ } // for
+ } // for
+ }
+
+ {
+ const f_status_t status = f_uint8ss_append(source, &destination);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(destination.used, source.used);
+ assert_int_equal(destination.size, source.used);
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+
+ assert_int_equal(destination.array[i].used, length_inner);
+ assert_int_equal(destination.array[i].size, length_inner);
+
+ for (f_array_length_t j = 0; j < length_inner; ++j) {
+ assert_int_equal(destination.array[i].array[j], j + 1);
+ } // for
+ } // for
+ }
+
+ for (f_array_length_t i = 0; i < source.used; ++i) {
+ free((void *) source.array[i].array);
+ } // for
+
+ for (f_array_length_t i = 0; i < destination.used; ++i) {
+ free((void *) destination.array[i].array);
+ } // for
+
+ free((void *) source.array);
+ free((void *) destination.array);
+}
+
+void test__f_type_array_uint8ss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t source = f_uint8s_t_initialize;
+ f_uint8ss_t destination = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &source);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8ss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ }
+
+ free((void *) source.array);
+ assert_null(destination.array);
+}
+
+void test__f_type_array_uint8ss_append__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_append
+#define _TEST__F_type_array__uint8ss_append
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_append()
+ */
+extern void test__f_type_array_uint8ss_append__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint8ss_append()
+ */
+extern void test__f_type_array_uint8ss_append__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_append()
+ */
+extern void test__f_type_array_uint8ss_append__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_append
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_decimate_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_decimate_by__works(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8ss_decimate_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint8ss_decimate_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_decimate_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_decimate_by
+#define _TEST__F_type_array__uint8ss_decimate_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_decimate_by()
+ */
+extern void test__f_type_array_uint8ss_decimate_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_decimate_by()
+ */
+extern void test__f_type_array_uint8ss_decimate_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_decimate_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_decrease_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_decrease_by__works(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8ss_decrease_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+void test__f_type_array_uint8ss_decrease_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_decrease_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_decrease_by
+#define _TEST__F_type_array__uint8ss_decrease_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_decrease_by()
+ */
+extern void test__f_type_array_uint8ss_decrease_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_decrease_by()
+ */
+extern void test__f_type_array_uint8ss_decrease_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_decrease_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_increase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_increase__works(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint8ss_increase(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8ss_increase__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8ss_increase(length, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8ss_increase__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_increase(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ free((void *) data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_increase
+#define _TEST__F_type_array__uint8ss_increase
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_increase()
+ */
+extern void test__f_type_array_uint8ss_increase__works(void **state);
+
+/**
+ * Test that the function returns F_data_not when asked to copy an empty structure.
+ *
+ * @see f_type_array_uint8ss_increase()
+ */
+extern void test__f_type_array_uint8ss_increase__returns_data_not(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_increase()
+ */
+extern void test__f_type_array_uint8ss_increase__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_increase
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_increase_by.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_increase_by__works(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ data.used = length;
+
+ const f_status_t status = f_uint8ss_increase_by(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, length);
+ assert_int_equal(data.size, length * 2);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8ss_increase_by__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_increase_by(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_increase_by
+#define _TEST__F_type_array__uint8ss_increase_by
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_increase_by()
+ */
+extern void test__f_type_array_uint8ss_increase_by__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_increase_by()
+ */
+extern void test__f_type_array_uint8ss_increase_by__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_increase_by
--- /dev/null
+#include "test-type_array.h"
+#include "test-type_array-uint8ss_resize.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__f_type_array_uint8ss_resize__works(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
+void test__f_type_array_uint8ss_resize__fails_on_invalid_parameter(void **state) {
+
+ const int length = 5;
+ f_uint8ss_t data = f_uint8ss_t_initialize;
+
+ {
+ const f_status_t status = f_uint8ss_resize(length, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, 0);
+ }
+
+ assert_null(data.array);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Type
+ * API Version: 0.5
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the array types in the type project.
+ */
+#ifndef _TEST__F_type_array__uint8ss_resize
+#define _TEST__F_type_array__uint8ss_resize
+
+/**
+ * Test that the function works.
+ *
+ * @see f_type_array_uint8ss_resize()
+ */
+extern void test__f_type_array_uint8ss_resize__works(void **state);
+
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_type_array_uint8ss_resize()
+ */
+extern void test__f_type_array_uint8ss_resize__fails_on_invalid_parameter(void **state);
+
+#endif // _TEST__F_type_array__uint8ss_resize
cmocka_unit_test(test__f_type_array_fll_idss_resize__works),
cmocka_unit_test(test__f_type_array_fll_idss_resize__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_adjust__works),
+ cmocka_unit_test(test__f_type_array_int8s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_append__works),
+ cmocka_unit_test(test__f_type_array_int8s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int8s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int8s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_increase__works),
+ cmocka_unit_test(test__f_type_array_int8s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int8s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8s_resize__works),
+ cmocka_unit_test(test__f_type_array_int8s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int8ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_int8ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8ss_append__works),
+ cmocka_unit_test(test__f_type_array_int8ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int8ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int8ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8ss_increase__works),
+ cmocka_unit_test(test__f_type_array_int8ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int8ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int8ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int8ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int16s_adjust__works),
+ cmocka_unit_test(test__f_type_array_int16s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16s_append__works),
+ cmocka_unit_test(test__f_type_array_int16s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int16s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int16s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16s_increase__works),
+ cmocka_unit_test(test__f_type_array_int16s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int16s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16s_resize__works),
+ cmocka_unit_test(test__f_type_array_int16s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int16ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_int16ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16ss_append__works),
+ cmocka_unit_test(test__f_type_array_int16ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int16ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int16ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16ss_increase__works),
+ cmocka_unit_test(test__f_type_array_int16ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int16ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int16ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int16ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int32s_adjust__works),
+ cmocka_unit_test(test__f_type_array_int32s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32s_append__works),
+ cmocka_unit_test(test__f_type_array_int32s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int32s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int32s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32s_increase__works),
+ cmocka_unit_test(test__f_type_array_int32s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int32s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32s_resize__works),
+ cmocka_unit_test(test__f_type_array_int32s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int32ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_int32ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32ss_append__works),
+ cmocka_unit_test(test__f_type_array_int32ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int32ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int32ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32ss_increase__works),
+ cmocka_unit_test(test__f_type_array_int32ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int32ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int32ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int32ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int64s_adjust__works),
+ cmocka_unit_test(test__f_type_array_int64s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64s_append__works),
+ cmocka_unit_test(test__f_type_array_int64s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int64s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int64s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64s_increase__works),
+ cmocka_unit_test(test__f_type_array_int64s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int64s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64s_resize__works),
+ cmocka_unit_test(test__f_type_array_int64s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int64ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_int64ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64ss_append__works),
+ cmocka_unit_test(test__f_type_array_int64ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int64ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int64ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64ss_increase__works),
+ cmocka_unit_test(test__f_type_array_int64ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int64ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int64ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int64ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int128s_adjust__works),
+ cmocka_unit_test(test__f_type_array_int128s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128s_append__works),
+ cmocka_unit_test(test__f_type_array_int128s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int128s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int128s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128s_increase__works),
+ cmocka_unit_test(test__f_type_array_int128s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int128s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128s_resize__works),
+ cmocka_unit_test(test__f_type_array_int128s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_int128ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_int128ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128ss_append__works),
+ cmocka_unit_test(test__f_type_array_int128ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_int128ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_int128ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128ss_increase__works),
+ cmocka_unit_test(test__f_type_array_int128ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_int128ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_int128ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int128ss_resize__fails_on_invalid_parameter),
+
cmocka_unit_test(test__f_type_array_states_adjust__works),
cmocka_unit_test(test__f_type_array_states_adjust__fails_on_invalid_parameter),
cmocka_unit_test(test__f_type_array_states_append__works),
cmocka_unit_test(test__f_type_array_statusss_increase_by__fails_on_invalid_parameter),
cmocka_unit_test(test__f_type_array_statusss_resize__works),
cmocka_unit_test(test__f_type_array_statusss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint8s_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint8s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8s_append__works),
+ cmocka_unit_test(test__f_type_array_uint8s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint8s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint8s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8s_increase__works),
+ cmocka_unit_test(test__f_type_array_uint8s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint8s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8s_resize__works),
+ cmocka_unit_test(test__f_type_array_uint8s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint8ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8ss_append__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8ss_increase__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint8ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint8ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint16s_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint16s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16s_append__works),
+ cmocka_unit_test(test__f_type_array_uint16s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint16s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint16s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16s_increase__works),
+ cmocka_unit_test(test__f_type_array_uint16s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint16s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16s_resize__works),
+ cmocka_unit_test(test__f_type_array_uint16s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint16ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16ss_append__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16ss_increase__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint16ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint16ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint32s_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint32s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32s_append__works),
+ cmocka_unit_test(test__f_type_array_uint32s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint32s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint32s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32s_increase__works),
+ cmocka_unit_test(test__f_type_array_uint32s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint32s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32s_resize__works),
+ cmocka_unit_test(test__f_type_array_uint32s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint32ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32ss_append__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32ss_increase__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint32ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint32ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint64s_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint64s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64s_append__works),
+ cmocka_unit_test(test__f_type_array_uint64s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint64s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint64s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64s_increase__works),
+ cmocka_unit_test(test__f_type_array_uint64s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint64s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64s_resize__works),
+ cmocka_unit_test(test__f_type_array_uint64s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint64ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64ss_append__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64ss_increase__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint64ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint64ss_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint128s_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint128s_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128s_append__works),
+ cmocka_unit_test(test__f_type_array_uint128s_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128s_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128s_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint128s_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128s_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint128s_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128s_increase__works),
+ cmocka_unit_test(test__f_type_array_uint128s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128s_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128s_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint128s_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128s_resize__works),
+ cmocka_unit_test(test__f_type_array_uint128s_resize__fails_on_invalid_parameter),
+
+ cmocka_unit_test(test__f_type_array_uint128ss_adjust__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_adjust__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128ss_append__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_append__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128ss_append__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128ss_decimate_by__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_decimate_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128ss_decrease_by__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_decrease_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128ss_increase__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128ss_increase__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128ss_increase_by__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_increase_by__fails_on_invalid_parameter),
+ cmocka_unit_test(test__f_type_array_uint128ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint128ss_resize__fails_on_invalid_parameter),
};
return cmocka_run_group_tests(tests, setup, setdown);
#include "test-type_array-fll_idss_increase.h"
#include "test-type_array-fll_idss_increase_by.h"
#include "test-type_array-fll_idss_resize.h"
+#include "test-type_array-int8s_adjust.h"
+#include "test-type_array-int8s_append.h"
+#include "test-type_array-int8s_decimate_by.h"
+#include "test-type_array-int8s_decrease_by.h"
+#include "test-type_array-int8s_increase.h"
+#include "test-type_array-int8s_increase_by.h"
+#include "test-type_array-int8s_resize.h"
+#include "test-type_array-int8ss_adjust.h"
+#include "test-type_array-int8ss_append.h"
+#include "test-type_array-int8ss_decimate_by.h"
+#include "test-type_array-int8ss_decrease_by.h"
+#include "test-type_array-int8ss_increase.h"
+#include "test-type_array-int8ss_increase_by.h"
+#include "test-type_array-int8ss_resize.h"
+#include "test-type_array-int16s_adjust.h"
+#include "test-type_array-int16s_append.h"
+#include "test-type_array-int16s_decimate_by.h"
+#include "test-type_array-int16s_decrease_by.h"
+#include "test-type_array-int16s_increase.h"
+#include "test-type_array-int16s_increase_by.h"
+#include "test-type_array-int16s_resize.h"
+#include "test-type_array-int16ss_adjust.h"
+#include "test-type_array-int16ss_append.h"
+#include "test-type_array-int16ss_decimate_by.h"
+#include "test-type_array-int16ss_decrease_by.h"
+#include "test-type_array-int16ss_increase.h"
+#include "test-type_array-int16ss_increase_by.h"
+#include "test-type_array-int16ss_resize.h"
+#include "test-type_array-int32s_adjust.h"
+#include "test-type_array-int32s_append.h"
+#include "test-type_array-int32s_decimate_by.h"
+#include "test-type_array-int32s_decrease_by.h"
+#include "test-type_array-int32s_increase.h"
+#include "test-type_array-int32s_increase_by.h"
+#include "test-type_array-int32s_resize.h"
+#include "test-type_array-int32ss_adjust.h"
+#include "test-type_array-int32ss_append.h"
+#include "test-type_array-int32ss_decimate_by.h"
+#include "test-type_array-int32ss_decrease_by.h"
+#include "test-type_array-int32ss_increase.h"
+#include "test-type_array-int32ss_increase_by.h"
+#include "test-type_array-int32ss_resize.h"
+#include "test-type_array-int64s_adjust.h"
+#include "test-type_array-int64s_append.h"
+#include "test-type_array-int64s_decimate_by.h"
+#include "test-type_array-int64s_decrease_by.h"
+#include "test-type_array-int64s_increase.h"
+#include "test-type_array-int64s_increase_by.h"
+#include "test-type_array-int64s_resize.h"
+#include "test-type_array-int64ss_adjust.h"
+#include "test-type_array-int64ss_append.h"
+#include "test-type_array-int64ss_decimate_by.h"
+#include "test-type_array-int64ss_decrease_by.h"
+#include "test-type_array-int64ss_increase.h"
+#include "test-type_array-int64ss_increase_by.h"
+#include "test-type_array-int64ss_resize.h"
+#include "test-type_array-int128s_adjust.h"
+#include "test-type_array-int128s_append.h"
+#include "test-type_array-int128s_decimate_by.h"
+#include "test-type_array-int128s_decrease_by.h"
+#include "test-type_array-int128s_increase.h"
+#include "test-type_array-int128s_increase_by.h"
+#include "test-type_array-int128s_resize.h"
+#include "test-type_array-int128ss_adjust.h"
+#include "test-type_array-int128ss_append.h"
+#include "test-type_array-int128ss_decimate_by.h"
+#include "test-type_array-int128ss_decrease_by.h"
+#include "test-type_array-int128ss_increase.h"
+#include "test-type_array-int128ss_increase_by.h"
+#include "test-type_array-int128ss_resize.h"
#include "test-type_array-states_adjust.h"
#include "test-type_array-states_append.h"
#include "test-type_array-states_decimate_by.h"
#include "test-type_array-statusss_increase.h"
#include "test-type_array-statusss_increase_by.h"
#include "test-type_array-statusss_resize.h"
+#include "test-type_array-uint8s_adjust.h"
+#include "test-type_array-uint8s_append.h"
+#include "test-type_array-uint8s_decimate_by.h"
+#include "test-type_array-uint8s_decrease_by.h"
+#include "test-type_array-uint8s_increase.h"
+#include "test-type_array-uint8s_increase_by.h"
+#include "test-type_array-uint8s_resize.h"
+#include "test-type_array-uint8ss_adjust.h"
+#include "test-type_array-uint8ss_append.h"
+#include "test-type_array-uint8ss_decimate_by.h"
+#include "test-type_array-uint8ss_decrease_by.h"
+#include "test-type_array-uint8ss_increase.h"
+#include "test-type_array-uint8ss_increase_by.h"
+#include "test-type_array-uint8ss_resize.h"
+#include "test-type_array-uint16s_adjust.h"
+#include "test-type_array-uint16s_append.h"
+#include "test-type_array-uint16s_decimate_by.h"
+#include "test-type_array-uint16s_decrease_by.h"
+#include "test-type_array-uint16s_increase.h"
+#include "test-type_array-uint16s_increase_by.h"
+#include "test-type_array-uint16s_resize.h"
+#include "test-type_array-uint16ss_adjust.h"
+#include "test-type_array-uint16ss_append.h"
+#include "test-type_array-uint16ss_decimate_by.h"
+#include "test-type_array-uint16ss_decrease_by.h"
+#include "test-type_array-uint16ss_increase.h"
+#include "test-type_array-uint16ss_increase_by.h"
+#include "test-type_array-uint16ss_resize.h"
+#include "test-type_array-uint32s_adjust.h"
+#include "test-type_array-uint32s_append.h"
+#include "test-type_array-uint32s_decimate_by.h"
+#include "test-type_array-uint32s_decrease_by.h"
+#include "test-type_array-uint32s_increase.h"
+#include "test-type_array-uint32s_increase_by.h"
+#include "test-type_array-uint32s_resize.h"
+#include "test-type_array-uint32ss_adjust.h"
+#include "test-type_array-uint32ss_append.h"
+#include "test-type_array-uint32ss_decimate_by.h"
+#include "test-type_array-uint32ss_decrease_by.h"
+#include "test-type_array-uint32ss_increase.h"
+#include "test-type_array-uint32ss_increase_by.h"
+#include "test-type_array-uint32ss_resize.h"
+#include "test-type_array-uint64s_adjust.h"
+#include "test-type_array-uint64s_append.h"
+#include "test-type_array-uint64s_decimate_by.h"
+#include "test-type_array-uint64s_decrease_by.h"
+#include "test-type_array-uint64s_increase.h"
+#include "test-type_array-uint64s_increase_by.h"
+#include "test-type_array-uint64s_resize.h"
+#include "test-type_array-uint64ss_adjust.h"
+#include "test-type_array-uint64ss_append.h"
+#include "test-type_array-uint64ss_decimate_by.h"
+#include "test-type_array-uint64ss_decrease_by.h"
+#include "test-type_array-uint64ss_increase.h"
+#include "test-type_array-uint64ss_increase_by.h"
+#include "test-type_array-uint64ss_resize.h"
+#include "test-type_array-uint128s_adjust.h"
+#include "test-type_array-uint128s_append.h"
+#include "test-type_array-uint128s_decimate_by.h"
+#include "test-type_array-uint128s_decrease_by.h"
+#include "test-type_array-uint128s_increase.h"
+#include "test-type_array-uint128s_increase_by.h"
+#include "test-type_array-uint128s_resize.h"
+#include "test-type_array-uint128ss_adjust.h"
+#include "test-type_array-uint128ss_append.h"
+#include "test-type_array-uint128ss_decimate_by.h"
+#include "test-type_array-uint128ss_decrease_by.h"
+#include "test-type_array-uint128ss_increase.h"
+#include "test-type_array-uint128ss_increase_by.h"
+#include "test-type_array-uint128ss_resize.h"
#ifdef __cplusplus
extern "C" {
projects / fll / commitdiff