This does not add tests for the join digits flag.
Such tests will be added at a later time.
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.c test-fss-payload_header_map-abstruse_uint8s.c
+build_sources_program test-fss-payload_header_map-abstruse_int16s.c test-fss-payload_header_map-abstruse_uint16s.c
+build_sources_program test-fss-payload_header_map-abstruse_int32s.c test-fss-payload_header_map-abstruse_uint32s.c
+build_sources_program test-fss-payload_header_map-abstruse_int64s.c test-fss-payload_header_map-abstruse_uint64s.c
build_sources_program test-fss-payload_header_map-abstruse_signed.c test-fss-payload_header_map-abstruse_unsigned.c
+build_sources_program test-fss-payload_header_map-abstruse_signeds.c test-fss-payload_header_map-abstruse_unsigneds.c
build_sources_program test-fss.c data-fss.c help-fss.c
c
1
-012345
+12345
1
-32700
1
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+555
+7777
--- /dev/null
+c
+3
+12345
+-32700
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+77777777
--- /dev/null
+c
+3
+123456789
+-2147483600
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+77777777
--- /dev/null
+c
+4
+123456789
+-9876543210
+-1
+-9223372036854775000
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55
+77
--- /dev/null
+c
+3
+12
+-120
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+77777777
--- /dev/null
+c
+3
+123456789
+-9876543210
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+7777
--- /dev/null
+c
+2
+1234
+65500
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+77777777
--- /dev/null
+c
+2
+123456789
+4294967200
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+77777777
--- /dev/null
+c
+3
+123456789
+9876543210
+18446744073709550000
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55
+77
--- /dev/null
+c
+2
+25
+250
--- /dev/null
+a
+4
+0
+1
+2
+3
--- /dev/null
+b
+3
+44
+55555
+77777777
--- /dev/null
+c
+2
+123456789
+9876543210
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+555
+7777
+c
+3
+012345
+-32700
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+77777777
+c
+3
+0123456789
+-2147483600
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+77777777
+c
+4
+0123456789
+-9876543210
+-1
+-9223372036854775000
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55
+77
+c
+3
+012
+-120
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+77777777
+c
+3
+0123456789
+-9876543210
+-1
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+7777
+c
+2
+01234
+65500
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+77777777
+c
+2
+0123456789
+4294967200
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+77777777
+c
+3
+0123456789
+9876543210
+18446744073709550000
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55
+77
+c
+2
+025
+250
--- /dev/null
+a
+4
+0
+1
+2
+3
+b
+3
+44
+55555
+77777777
+c
+2
+0123456789
+9876543210
for (f_number_unsigned_t i = 0; i < count; ++i, ++expects->used) {
max = 255;
- expects->array[expects->used].name.used = 0;
+ expects->array[expects->used].key.used = 0;
expects->array[expects->used].value.used = 0;
- status = f_string_dynamic_append(object, &expects->array[expects->used].name);
+ status = f_string_dynamic_append(object, &expects->array[expects->used].key);
assert_true(F_status_is_error_not(status));
- status = f_string_dynamic_terminate_after(&expects->array[expects->used].name);
+ status = f_string_dynamic_terminate_after(&expects->array[expects->used].key);
assert_true(F_status_is_error_not(status));
status = f_memory_array_increase_by(max, sizeof(f_string_t), (void **) &expects->array[expects->used].value.string, &expects->array[expects->used].value.used, &expects->array[expects->used].value.size);
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_int16s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int16s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int16s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int16s_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_int32s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int32s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int32s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int32s_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_int64s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int64s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int64s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int64s_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_int8s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_int8s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_int8s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_int8s_h
for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
- assert_int_equal(destinations.array[i].name.used, expects.array[i].name.used);
+ 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].name.string, expects.array[i].name.string);
+ 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
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_signeds.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_signeds__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_signeds_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_signeds_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_uint16s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint16s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint16s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint16s_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_uint32s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint32s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint32s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint32s_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_uint64s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint64s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint64s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint64s_h
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_uint8s.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_uint8s__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_uint8s_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_uint8s_h
for (f_number_unsigned_t i = 0; i < destinations.used; ++i) {
- assert_int_equal(destinations.array[i].name.used, expects.array[i].name.used);
+ 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].name.string, expects.array[i].name.string);
+ 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
--- /dev/null
+#include "test-fss.h"
+#include "test-fss-payload_header_map-abstruse_unsigneds.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void test__fl_fss_payload_header_map__abstruse_unsigneds__works_combined(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", "combined-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;
+
+ 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", "combined-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_h
+#define _TEST__FL_fss_payload_header_map__abstruse_unsigneds_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_combined(void **state);
+
+#endif // _TEST__FL_fss_payload_header_map__abstruse_unsigneds_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_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int16s__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int32s__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_int64s__works_combined),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_signed__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_signeds__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint8s__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint16s__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint32s__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_uint64s__works_combined),
cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_unsigned__works_combined),
+ cmocka_unit_test(test__fl_fss_payload_header_map__abstruse_unsigneds__works_combined),
#ifndef _di_level_0_parameter_checking_
cmocka_unit_test(test__fl_fss_basic_content_read__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.h"
+#include "test-fss-payload_header_map-abstruse_int16s.h"
+#include "test-fss-payload_header_map-abstruse_int32s.h"
+#include "test-fss-payload_header_map-abstruse_int64s.h"
#include "test-fss-payload_header_map-abstruse_signed.h"
+#include "test-fss-payload_header_map-abstruse_signeds.h"
+#include "test-fss-payload_header_map-abstruse_uint8s.h"
+#include "test-fss-payload_header_map-abstruse_uint16s.h"
+#include "test-fss-payload_header_map-abstruse_uint32s.h"
+#include "test-fss-payload_header_map-abstruse_uint64s.h"
#include "test-fss-payload_header_map-abstruse_unsigned.h"
+#include "test-fss-payload_header_map-abstruse_unsigneds.h"
#ifdef __cplusplus
extern "C" {
projects / fll / commitdiff