build_sources_program test-fss-extended_content_read.c test-fss-extended_content_write.c test-fss-extended_object_read.c test-fss-extended_object_write.c
build_sources_program test-fss-extended_list_content_read.c test-fss-extended_list_content_write.c test-fss-extended_list_object_read.c test-fss-extended_list_object_write.c
build_sources_program test-fss-payload_header_map.c
+build_sources_program test-fss-payload_header_map-abstruse_int8s-join.c test-fss-payload_header_map-abstruse_uint8s-join.c
build_sources_program test-fss-payload_header_map-abstruse_int8s-split.c test-fss-payload_header_map-abstruse_uint8s-split.c
+build_sources_program test-fss-payload_header_map-abstruse_int16s-join.c test-fss-payload_header_map-abstruse_uint16s-join.c
build_sources_program test-fss-payload_header_map-abstruse_int16s-split.c test-fss-payload_header_map-abstruse_uint16s-split.c
+build_sources_program test-fss-payload_header_map-abstruse_int32s-join.c test-fss-payload_header_map-abstruse_uint32s-join.c
build_sources_program test-fss-payload_header_map-abstruse_int32s-split.c test-fss-payload_header_map-abstruse_uint32s-split.c
+build_sources_program test-fss-payload_header_map-abstruse_int64s-join.c test-fss-payload_header_map-abstruse_uint64s-join.c
build_sources_program test-fss-payload_header_map-abstruse_int64s-split.c test-fss-payload_header_map-abstruse_uint64s-split.c
build_sources_program test-fss-payload_header_map-abstruse_signed-join.c test-fss-payload_header_map-abstruse_unsigned-join.c
+build_sources_program test-fss-payload_header_map-abstruse_signeds-join.c test-fss-payload_header_map-abstruse_unsigneds-join.c
build_sources_program test-fss-payload_header_map-abstruse_signeds-split.c test-fss-payload_header_map-abstruse_unsigneds-split.c
build_sources_program test-fss.c data-fss.c help-fss.c
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 555 7777"
--- /dev/null
+c
+1
+"12345 -32700 -1"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 77777777"
--- /dev/null
+c
+1
+"123456789 -2147483600 -1"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 77777777"
--- /dev/null
+c
+1
+"123456789 -9876543210 -1 -9223372036854775000"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55 77"
--- /dev/null
+c
+1
+"12 -120 -1"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 77777777"
--- /dev/null
+c
+1
+"123456789 -9876543210 -1"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 7777"
--- /dev/null
+c
+1
+"1234 65500"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 77777777"
--- /dev/null
+c
+1
+"123456789 4294967200"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 77777777"
--- /dev/null
+c
+1
+"123456789 9876543210 18446744073709550000"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55 77"
--- /dev/null
+c
+1
+"25 250"
--- /dev/null
+a
+1
+"0 1 2 3"
--- /dev/null
+b
+1
+"44 55555 77777777"
--- /dev/null
+c
+1
+"123456789 9876543210"
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int16s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_int16s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_int16s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_i16s.used = 0;
+ headers.array[0].value.type = f_abstruse_int16s_e;
+ is_a = &headers.array[0].value.is.a_i16s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_int16s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_int16s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int16s_join_h
+
+/**
+ * Test that the function works for abstruse_int16s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_int16s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int16s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int32s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_int32s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_int32s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_i32s.used = 0;
+ headers.array[0].value.type = f_abstruse_int32s_e;
+ is_a = &headers.array[0].value.is.a_i32s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_int32s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_int32s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int32s_join_h
+
+/**
+ * Test that the function works for abstruse_int32s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_int32s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int32s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int64s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_int64s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_int64s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_i64s.used = 0;
+ headers.array[0].value.type = f_abstruse_int64s_e;
+ is_a = &headers.array[0].value.is.a_i64s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_int64s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_int64s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int64s_join_h
+
+/**
+ * Test that the function works for abstruse_int64s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_int64s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int64s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int8s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_int8s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_int8s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_i8s.used = 0;
+ headers.array[0].value.type = f_abstruse_int8s_e;
+ is_a = &headers.array[0].value.is.a_i8s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_int8s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_int8s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int8s_join_h
+
+/**
+ * Test that the function works for abstruse_int8s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_int8s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int8s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_signeds__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_signeds");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_number_signeds_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_signeds.used = 0;
+ headers.array[0].value.type = f_abstruse_signeds_e;
+ is_a = &headers.array[0].value.is.a_signeds;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_signeds", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_signeds_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_signeds_join_h
+
+/**
+ * Test that the function works for abstruse_signeds type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_signeds__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_signeds_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint16s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_uint16s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_uint16s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_u16s.used = 0;
+ headers.array[0].value.type = f_abstruse_uint16s_e;
+ is_a = &headers.array[0].value.is.a_u16s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_uint16s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_uint16s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint16s_join_h
+
+/**
+ * Test that the function works for abstruse_uint16s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_uint16s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint16s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint32s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_uint32s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_uint32s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_u32s.used = 0;
+ headers.array[0].value.type = f_abstruse_uint32s_e;
+ is_a = &headers.array[0].value.is.a_u32s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_uint32s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_uint32s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint32s_join_h
+
+/**
+ * Test that the function works for abstruse_uint32s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_uint32s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint32s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint64s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_uint64s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_uint64s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_u64s.used = 0;
+ headers.array[0].value.type = f_abstruse_uint64s_e;
+ is_a = &headers.array[0].value.is.a_u64s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ // atoll() cannot be used here due to needing an unsigned 64-bit and atoll() returns a signed 64-bit.
+ const f_number_signed_t number = strtoull(contents.array[is_a->used].string, 0, 10);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_uint64s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_uint64s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint64s_join_h
+
+/**
+ * Test that the function works for abstruse_uint64s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_uint64s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint64s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint8s__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_uint8s");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_uint8s_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_u8s.used = 0;
+ headers.array[0].value.type = f_abstruse_uint8s_e;
+ is_a = &headers.array[0].value.is.a_u8s;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_uint8s", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_uint8s_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint8s_join_h
+
+/**
+ * Test that the function works for abstruse_uint8s type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_uint8s__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint8s_join_h
--- /dev/null
+#include "test-fss.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_unsigneds__works_join(void **void_state) {
+
+ // Note: Each line should probably be at max 255 characters.
+ // The payload begins with a digit on the first line representing the number of Content lines following the Object line.
+ // Following the digit is a single Object line.
+ // Following the Object line is a line for each Content designated by the first line (can be 0).
+ // Following this Content line (even if 0 lines) should be the end of the test file or the start of the next set for the next line in the headers file.
+ FILE *file_variables = data__file_open__named("variables", "payload", "abstruse_unsigneds");
+ FILE *file_headers = 0;
+
+ assert_non_null(file_variables);
+
+ f_abstruse_maps_t headers = f_abstruse_maps_t_initialize;
+ f_state_t state = f_state_t_initialize;
+ f_fss_payload_header_state_t data = f_fss_payload_header_state_t_initialize;
+ f_string_dynamic_t object = f_string_dynamic_t_initialize;
+ f_string_dynamics_t contents = f_string_dynamics_t_initialize;
+ f_string_dynamic_t cache = f_string_dynamic_t_initialize;
+ f_string_maps_t destinations = f_string_maps_t_initialize;
+ f_string_maps_t expects = f_string_maps_t_initialize;
+ f_number_unsigneds_t *is_a = 0;
+
+ {
+ state.status = F_none;
+ state.data = &data;
+ data.cache = &cache;
+ data.flag |= f_fss_payload_header_map_flag_join_digits_e;
+
+ for (uint16_t at = 0; ; ++at) {
+
+ if (help__read_line_object(file_variables, &object)) break;
+ if (help__read_line_contents__single(file_variables, &contents)) break;
+
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ headers.array[0].key.used = 0;
+ headers.array[0].value.is.a_unsigneds.used = 0;
+ headers.array[0].value.type = f_abstruse_unsigneds_e;
+ is_a = &headers.array[0].value.is.a_unsigneds;
+
+ state.status = f_string_dynamic_append(object, &headers.array[headers.used].key);
+ assert_int_equal(state.status, F_okay);
+
+ state.status = f_memory_array_increase_by(contents.used, sizeof(f_number_signed_t), (void **) &is_a->array, &is_a->used, &is_a->size);
+ assert_true(F_status_is_error_not(state.status));
+
+ for (is_a->used = 0; is_a->used < contents.used; ) {
+
+ const f_number_signed_t number = atoll(contents.array[is_a->used].string);
+
+ if (!number) {
+ assert_int_equal(contents.array[is_a->used].string[0], '0');
+ }
+
+ is_a->array[is_a->used++] = number;
+ } // for
+
+ if (object.string) free(object.string);
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ ++headers.used;
+
+ file_headers = data__file_open__named_at("headers", "payload", "join-abstruse_unsigneds", at);
+ assert_non_null(file_headers);
+
+ help__read_line_object(file_headers, &object);
+
+ for (;;) {
+ state.status = f_memory_array_increase(state.step_small, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size);
+ assert_true(F_status_is_error_not(state.status));
+
+ if (help__read_line_expects__single(file_headers, object, &expects)) break;
+ } // for
+
+ fl_fss_payload_header_map(headers, &destinations, &state);
+ assert_int_equal(state.status, F_okay);
+ assert_int_equal(destinations.used, expects.used);
+
+ for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
+
+ assert_int_equal(destinations.array[i].key.used, expects.array[i].key.used);
+ assert_int_equal(destinations.array[i].value.used, expects.array[i].value.used);
+
+ assert_string_equal(destinations.array[i].key.string, expects.array[i].key.string);
+ assert_string_equal(destinations.array[i].value.string, expects.array[i].value.string);
+ } // for
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+ if (file_headers) fclose(file_headers);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+
+ file_headers = 0;
+
+ object.string = 0;
+ object.used = 0;
+ object.size = 0;
+
+ cache.string = 0;
+ cache.used = 0;
+ cache.size = 0;
+
+ contents.array = 0;
+ contents.used = 0;
+ contents.size = 0;
+
+ headers.array = 0;
+ headers.used = 0;
+ headers.size = 0;
+
+ destinations.array = 0;
+ destinations.used = 0;
+ destinations.size = 0;
+
+ expects.array = 0;
+ expects.used = 0;
+ expects.size = 0;
+ } // for
+ }
+
+ if (file_variables) fclose(file_variables);
+ if (file_headers) fclose(file_headers);
+
+ if (object.string) free(object.string);
+ if (cache.string) free(cache.string);
+
+ f_memory_arrays_resize(0, sizeof(f_string_dynamic_t), (void **) &contents.array, &contents.used, &contents.size, &f_string_dynamics_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_abstruse_map_t), (void **) &headers.array, &headers.used, &headers.size, &f_abstruse_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &destinations.array, &destinations.used, &destinations.size, &f_string_maps_delete_callback);
+ f_memory_arrays_resize(0, sizeof(f_string_map_t), (void **) &expects.array, &expects.used, &expects.size, &f_string_maps_delete_callback);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
--- /dev/null
+/**
+ * FLL - Level 2
+ *
+ * Project: FSS
+ * API Version: 0.6
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the fl_fss project.
+ */
+#ifndef _TEST__FL_fss_payload_header_map__abstruse_unsigneds_join_h
+#define _TEST__FL_fss_payload_header_map__abstruse_unsigneds_join_h
+
+/**
+ * Test that the function works for abstruse_unsigneds type.
+ *
+ * @see fl_fss_payload_header_map()
+ */
+extern void test__fl_fss_payload_header_map__abstruse_unsigneds__works_join(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_unsigneds_join_h
cmocka_unit_test(test__fl_fss_extended_list_object_read__works),
cmocka_unit_test(test__fl_fss_payload_header_map__returns_data_not),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int8s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int8s__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int16s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int16s__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int32s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int32s__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int64s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int64s__works_split),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_signed__works_join),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_signeds__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_signeds__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint8s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint8s__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint16s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint16s__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint32s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint32s__works_split),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint64s__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint64s__works_split),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_unsigned__works_join),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_unsigneds__works_join),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_unsigneds__works_split),
#ifndef _di_level_0_parameter_checking_
#include "test-fss-extended_list_object_read.h"
#include "test-fss-extended_list_object_write.h"
#include "test-fss-payload_header_map.h"
+#include "test-fss-payload_header_map-abstruse_int8s-join.h"
#include "test-fss-payload_header_map-abstruse_int8s-split.h"
+#include "test-fss-payload_header_map-abstruse_int16s-join.h"
#include "test-fss-payload_header_map-abstruse_int16s-split.h"
+#include "test-fss-payload_header_map-abstruse_int32s-join.h"
#include "test-fss-payload_header_map-abstruse_int32s-split.h"
+#include "test-fss-payload_header_map-abstruse_int64s-join.h"
#include "test-fss-payload_header_map-abstruse_int64s-split.h"
#include "test-fss-payload_header_map-abstruse_signed-join.h"
+#include "test-fss-payload_header_map-abstruse_signeds-join.h"
#include "test-fss-payload_header_map-abstruse_signeds-split.h"
+#include "test-fss-payload_header_map-abstruse_uint8s-join.h"
#include "test-fss-payload_header_map-abstruse_uint8s-split.h"
+#include "test-fss-payload_header_map-abstruse_uint16s-join.h"
#include "test-fss-payload_header_map-abstruse_uint16s-split.h"
+#include "test-fss-payload_header_map-abstruse_uint32s-join.h"
#include "test-fss-payload_header_map-abstruse_uint32s-split.h"
+#include "test-fss-payload_header_map-abstruse_uint64s-join.h"
#include "test-fss-payload_header_map-abstruse_uint64s-split.h"
#include "test-fss-payload_header_map-abstruse_unsigned-join.h"
+#include "test-fss-payload_header_map-abstruse_unsigneds-join.h"
#include "test-fss-payload_header_map-abstruse_unsigneds-split.h"
#ifdef __cplusplus
projects / fll / commitdiff