Many of the testfile files have "tests" when they instead should have "test".
The f_print must have a clang specific define passed to work-around a clang problem.
I noticed that I forgot to implement several "returns_data_not" unit test while writing the f_fss unit tests.
Provide these missing unit tests for the f_type_array project unit tests.
This project is my de-facto standard for basing all of my standard data type unit tests and needs to be as correct and up to date as possible.
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
main:
# Disable mocks until mocking can be fixed for this project.
#build settings-mocks
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
search_shared yes
search_static yes
+defines-clang -D_clang_not_a_compile_time_constant_workaround_
+
flags -O0 -z now -g -fdiagnostics-color=always -Wno-logical-not-parentheses -Wno-parentheses
flags-clang -Wno-logical-op-parentheses
flags-test -fstack-protector -Wall
search_static yes
defines -Ibuild/includes
+defines-clang -D_clang_not_a_compile_time_constant_workaround_
defines_static -Lbuild/libraries/static
defines_shared -Lbuild/libraries/shared
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings-mocks individual tests
+ build settings-mocks individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
assert_null(data.array);
}
+void test__f_type_array_array_lengths_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_array_lengths_t data = f_array_lengths_t_initialize;
+
+ {
+ const f_status_t status = f_array_lengths_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_array_lengths_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_array_lengths_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_array_lengths_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_array_lengths_decimate_by()
+ */
+extern void test__f_type_array_array_lengths_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_array_lengths_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_array_lengths_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_array_lengths_t data = f_array_lengths_t_initialize;
+
+ {
+ const f_status_t status = f_array_lengths_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_array_lengths_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_array_lengths_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_array_lengths_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_array_lengths_decrease_by()
+ */
+extern void test__f_type_array_array_lengths_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_array_lengths_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_array_lengths_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_array_lengths_t data = f_array_lengths_t_initialize;
+
+ {
+ const f_status_t status = f_array_lengths_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_array_lengths_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_array_lengths_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_array_lengths_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_array_lengths_increase_by()
+ */
+extern void test__f_type_array_array_lengths_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_array_lengths_increase_by()
assert_null(data.array);
}
+void test__f_type_array_cells_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_cells_t data = f_cells_t_initialize;
+
+ {
+ const f_status_t status = f_cells_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_cells_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_cells_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_cells_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_cells_decimate_by()
+ */
+extern void test__f_type_array_cells_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_cells_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_cells_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_cells_t data = f_cells_t_initialize;
+
+ {
+ const f_status_t status = f_cells_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_cells_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_cells_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_cells_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_cells_decrease_by()
+ */
+extern void test__f_type_array_cells_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_cells_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_cells_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_cells_t data = f_cells_t_initialize;
+
+ {
+ const f_status_t status = f_cells_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_cells_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_cells_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_cells_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_cells_increase_by()
+ */
+extern void test__f_type_array_cells_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_cells_increase_by()
extern "C" {
#endif
+void test__f_type_array_cellss_append_all__parameter_checking(void **state) {
+
+ const f_cellss_t data = f_cellss_t_initialize;
+
+ {
+ const f_status_t status = f_cellss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_type_array_cellss_append_all__returns_data_not(void **state) {
const int length = 5;
free((void *) source.array);
}
-void test__f_type_array_cellss_append_all__parameter_checking(void **state) {
-
- const f_cellss_t data = f_cellss_t_initialize;
-
- {
- const f_status_t status = f_cellss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
void test__f_type_array_cellss_append_all__works(void **state) {
const int length = 5;
assert_null(data.array);
}
+void test__f_type_array_fll_ids_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_fll_ids_t data = f_fll_ids_t_initialize;
+
+ {
+ const f_status_t status = f_fll_ids_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_fll_ids_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_fll_ids_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_fll_ids_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_fll_ids_decimate_by()
+ */
+extern void test__f_type_array_fll_ids_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_fll_ids_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_fll_ids_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_fll_ids_t data = f_fll_ids_t_initialize;
+
+ {
+ const f_status_t status = f_fll_ids_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_fll_ids_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_fll_ids_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_fll_ids_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_fll_ids_decrease_by()
+ */
+extern void test__f_type_array_fll_ids_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_fll_ids_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_fll_ids_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_fll_ids_t data = f_fll_ids_t_initialize;
+
+ {
+ const f_status_t status = f_fll_ids_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_fll_ids_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_fll_ids_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_fll_ids_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_fll_ids_increase_by()
+ */
+extern void test__f_type_array_fll_ids_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_fll_ids_increase_by()
assert_null(data.array);
}
+void test__f_type_array_int128s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int128s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int128s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int128s_decimate_by()
+ */
+extern void test__f_type_array_int128s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int128s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_int128s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int128s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int128s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int128s_decrease_by()
+ */
+extern void test__f_type_array_int128s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int128s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_int128s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int128s_t data = f_int128s_t_initialize;
+
+ {
+ const f_status_t status = f_int128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int128s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int128s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int128s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int128s_increase_by()
+ */
+extern void test__f_type_array_int128s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int128s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_int16s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int16s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int16s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int16s_decimate_by()
+ */
+extern void test__f_type_array_int16s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int16s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_int16s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int16s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int16s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int16s_decrease_by()
+ */
+extern void test__f_type_array_int16s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int16s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_int16s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int16s_t data = f_int16s_t_initialize;
+
+ {
+ const f_status_t status = f_int16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int16s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int16s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int16s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int16s_increase_by()
+ */
+extern void test__f_type_array_int16s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int16s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_int32s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int32s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int32s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int32s_decimate_by()
+ */
+extern void test__f_type_array_int32s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int32s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_int32s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int32s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int32s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int32s_decrease_by()
+ */
+extern void test__f_type_array_int32s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int32s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_int32s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int32s_t data = f_int32s_t_initialize;
+
+ {
+ const f_status_t status = f_int32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int32s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int32s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int32s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int32s_increase_by()
+ */
+extern void test__f_type_array_int32s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int32s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_int64s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int64s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int64s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int64s_decimate_by()
+ */
+extern void test__f_type_array_int64s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int64s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_int64s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int64s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int64s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int64s_decrease_by()
+ */
+extern void test__f_type_array_int64s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int64s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_int64s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int64s_t data = f_int64s_t_initialize;
+
+ {
+ const f_status_t status = f_int64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int64s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int64s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int64s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int64s_increase_by()
+ */
+extern void test__f_type_array_int64s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int64s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_int8s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int8s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int8s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int8s_decimate_by()
+ */
+extern void test__f_type_array_int8s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int8s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_int8s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int8s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int8s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int8s_decrease_by()
+ */
+extern void test__f_type_array_int8s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int8s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_int8s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_int8s_t data = f_int8s_t_initialize;
+
+ {
+ const f_status_t status = f_int8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_int8s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_int8s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_int8s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_int8s_increase_by()
+ */
+extern void test__f_type_array_int8s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_int8s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_states_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_states_t data = f_states_t_initialize;
+
+ {
+ const f_status_t status = f_states_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_states_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_states_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_states_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_states_decimate_by()
+ */
+extern void test__f_type_array_states_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_states_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_states_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_states_t data = f_states_t_initialize;
+
+ {
+ const f_status_t status = f_states_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_states_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_states_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_states_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_states_decrease_by()
+ */
+extern void test__f_type_array_states_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_states_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_states_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_states_t data = f_states_t_initialize;
+
+ {
+ const f_status_t status = f_states_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_states_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_states_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_states_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_states_increase_by()
+ */
+extern void test__f_type_array_states_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_states_increase_by()
assert_null(data.array);
}
+void test__f_type_array_statuss_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_statuss_t data = f_statuss_t_initialize;
+
+ {
+ const f_status_t status = f_statuss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_statuss_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_statuss_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_statuss_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_statuss_decimate_by()
+ */
+extern void test__f_type_array_statuss_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_statuss_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_statuss_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_statuss_t data = f_statuss_t_initialize;
+
+ {
+ const f_status_t status = f_statuss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_statuss_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_statuss_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_statuss_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_statuss_decrease_by()
+ */
+extern void test__f_type_array_statuss_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_statuss_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_statuss_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_statuss_t data = f_statuss_t_initialize;
+
+ {
+ const f_status_t status = f_statuss_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_statuss_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_statuss_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_statuss_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_statuss_increase_by()
+ */
+extern void test__f_type_array_statuss_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_statuss_increase_by()
assert_null(data.array);
}
+void test__f_type_array_uint128s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint128s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint128s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint128s_decimate_by()
+ */
+extern void test__f_type_array_uint128s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint128s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_uint128s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint128s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint128s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint128s_decrease_by()
+ */
+extern void test__f_type_array_uint128s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint128s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_uint128s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint128s_t data = f_uint128s_t_initialize;
+
+ {
+ const f_status_t status = f_uint128s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint128s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint128s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint128s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint128s_increase_by()
+ */
+extern void test__f_type_array_uint128s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint128s_increase_by()
extern void test__f_type_array_uint128ss_adjust__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint128ss_increase_by()
+ */
+extern void test__f_type_array_uint128ss_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint128ss_adjust()
assert_null(data.array);
}
+void test__f_type_array_uint16s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint16s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint16s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint16s_decimate_by()
+ */
+extern void test__f_type_array_uint16s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint16s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_uint16s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint16s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint16s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint16s_decrease_by()
+ */
+extern void test__f_type_array_uint16s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint16s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_uint16s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint16s_t data = f_uint16s_t_initialize;
+
+ {
+ const f_status_t status = f_uint16s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint16s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint16s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint16s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint16s_increase_by()
+ */
+extern void test__f_type_array_uint16s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint16s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_uint32s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint32s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint32s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint32s_decimate_by()
+ */
+extern void test__f_type_array_uint32s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint32s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_uint32s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint32s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint32s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint32s_decrease_by()
+ */
+extern void test__f_type_array_uint32s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint32s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_uint32s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint32s_t data = f_uint32s_t_initialize;
+
+ {
+ const f_status_t status = f_uint32s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint32s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint32s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint32s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint32s_increase_by()
+ */
+extern void test__f_type_array_uint32s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint32s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_uint64s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint64s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint64s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint64s_decimate_by()
+ */
+extern void test__f_type_array_uint64s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint64s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_uint64s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint64s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint64s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint64s_decrease_by()
+ */
+extern void test__f_type_array_uint64s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint64s_decrease_by()
assert_null(data.array);
}
+void test__f_type_array_uint64s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint64s_t data = f_uint64s_t_initialize;
+
+ {
+ const f_status_t status = f_uint64s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint64s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint64s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint64s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint64s_increase_by()
+ */
+extern void test__f_type_array_uint64s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint64s_increase_by()
assert_null(data.array);
}
+void test__f_type_array_uint8s_decimate_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_decimate_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint8s_decimate_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint8s_decimate_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint8s_decimate_by()
+ */
+extern void test__f_type_array_uint8s_decimate_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint8s_decimate_by()
assert_null(data.array);
}
+void test__f_type_array_uint8s_decrease_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_decrease_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint8s_decrease_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint8s_decrease_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint8s_decrease_by()
+ */
+extern void test__f_type_array_uint8s_decrease_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint8s_decrease_by()
assert_null(data.array);
}
+
+void test__f_type_array_uint8s_increase_by__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_uint8s_t data = f_uint8s_t_initialize;
+
+ {
+ const f_status_t status = f_uint8s_resize(length, &data);
+
+ assert_int_equal(status, F_none);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ {
+ const f_status_t status = f_uint8s_increase_by(0, &data);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(data.used, 0);
+ assert_int_equal(data.size, length);
+ }
+
+ free((void *) data.array);
+}
+
void test__f_type_array_uint8s_increase_by__works(void **state) {
const int length = 5;
extern void test__f_type_array_uint8s_increase_by__parameter_checking(void **state);
/**
+ * Test that the function returns F_data_not.
+ *
+ * @see f_uint8s_increase_by()
+ */
+extern void test__f_type_array_uint8s_increase_by__returns_data_not(void **state);
+
+/**
* Test that the function works.
*
* @see f_uint8s_increase_by()
int main(void) {
const struct CMUnitTest tests[] = {
+ cmocka_unit_test(test__f_type_array_array_lengths_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_array_lengths_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_array_lengths_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_array_lengths_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_array_lengths_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_array_lengths_adjust__works),
cmocka_unit_test(test__f_type_array_array_lengths_append__works),
cmocka_unit_test(test__f_type_array_array_lengths_append_all__works),
cmocka_unit_test(test__f_type_array_array_lengthss_increase_by__works),
cmocka_unit_test(test__f_type_array_array_lengthss_resize__works),
+ cmocka_unit_test(test__f_type_array_cells_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_cells_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_cells_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_cells_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_cells_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_cells_adjust__works),
cmocka_unit_test(test__f_type_array_cells_append__works),
cmocka_unit_test(test__f_type_array_cells_append_all__works),
cmocka_unit_test(test__f_type_array_cellss_increase_by__works),
cmocka_unit_test(test__f_type_array_cellss_resize__works),
+ cmocka_unit_test(test__f_type_array_fll_ids_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_fll_ids_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_fll_ids_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_fll_ids_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_fll_ids_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_fll_ids_adjust__works),
cmocka_unit_test(test__f_type_array_fll_ids_append__works),
cmocka_unit_test(test__f_type_array_fll_ids_append_all__works),
cmocka_unit_test(test__f_type_array_fll_idss_increase_by__works),
cmocka_unit_test(test__f_type_array_fll_idss_resize__works),
+ cmocka_unit_test(test__f_type_array_int8s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int8s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_int8s_adjust__works),
cmocka_unit_test(test__f_type_array_int8s_append__works),
cmocka_unit_test(test__f_type_array_int8s_append_all__works),
cmocka_unit_test(test__f_type_array_int8ss_increase_by__works),
cmocka_unit_test(test__f_type_array_int8ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int16s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int16s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_int16s_adjust__works),
cmocka_unit_test(test__f_type_array_int16s_append__works),
cmocka_unit_test(test__f_type_array_int16s_append_all__works),
cmocka_unit_test(test__f_type_array_int16ss_increase_by__works),
cmocka_unit_test(test__f_type_array_int16ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int32s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int32s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_int32s_adjust__works),
cmocka_unit_test(test__f_type_array_int32s_append__works),
cmocka_unit_test(test__f_type_array_int32s_append_all__works),
cmocka_unit_test(test__f_type_array_int32ss_increase_by__works),
cmocka_unit_test(test__f_type_array_int32ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int64s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int64s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_int64s_adjust__works),
cmocka_unit_test(test__f_type_array_int64s_append__works),
cmocka_unit_test(test__f_type_array_int64s_append_all__works),
cmocka_unit_test(test__f_type_array_int64ss_increase_by__works),
cmocka_unit_test(test__f_type_array_int64ss_resize__works),
+ cmocka_unit_test(test__f_type_array_int128s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_int128s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_int128s_adjust__works),
cmocka_unit_test(test__f_type_array_int128s_append__works),
cmocka_unit_test(test__f_type_array_int128s_append_all__works),
cmocka_unit_test(test__f_type_array_int128ss_increase_by__works),
cmocka_unit_test(test__f_type_array_int128ss_resize__works),
+ cmocka_unit_test(test__f_type_array_states_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_states_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_states_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_states_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_states_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_states_adjust__works),
cmocka_unit_test(test__f_type_array_states_append__works),
cmocka_unit_test(test__f_type_array_states_append_all__works),
cmocka_unit_test(test__f_type_array_statess_increase_by__works),
cmocka_unit_test(test__f_type_array_statess_resize__works),
+ cmocka_unit_test(test__f_type_array_statuss_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_statuss_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_statuss_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_statuss_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_statuss_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_statuss_adjust__works),
cmocka_unit_test(test__f_type_array_statuss_append__works),
cmocka_unit_test(test__f_type_array_statuss_append_all__works),
cmocka_unit_test(test__f_type_array_statusss_increase_by__works),
cmocka_unit_test(test__f_type_array_statusss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint8s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint8s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_uint8s_adjust__works),
cmocka_unit_test(test__f_type_array_uint8s_append__works),
cmocka_unit_test(test__f_type_array_uint8s_append_all__works),
cmocka_unit_test(test__f_type_array_uint8ss_increase_by__works),
cmocka_unit_test(test__f_type_array_uint8ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint16s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint16s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_uint16s_adjust__works),
cmocka_unit_test(test__f_type_array_uint16s_append__works),
cmocka_unit_test(test__f_type_array_uint16s_append_all__works),
cmocka_unit_test(test__f_type_array_uint16ss_increase_by__works),
cmocka_unit_test(test__f_type_array_uint16ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint32s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint32s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_uint32s_adjust__works),
cmocka_unit_test(test__f_type_array_uint32s_append__works),
cmocka_unit_test(test__f_type_array_uint32s_append_all__works),
cmocka_unit_test(test__f_type_array_uint32ss_increase_by__works),
cmocka_unit_test(test__f_type_array_uint32ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint64s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint64s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_uint64s_adjust__works),
cmocka_unit_test(test__f_type_array_uint64s_append__works),
cmocka_unit_test(test__f_type_array_uint64s_append_all__works),
cmocka_unit_test(test__f_type_array_uint64ss_increase_by__works),
cmocka_unit_test(test__f_type_array_uint64ss_resize__works),
+ cmocka_unit_test(test__f_type_array_uint128s_append_all__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128s_decimate_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128s_decrease_by__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128s_increase__returns_data_not),
+ cmocka_unit_test(test__f_type_array_uint128s_increase_by__returns_data_not),
+
cmocka_unit_test(test__f_type_array_uint128s_adjust__works),
cmocka_unit_test(test__f_type_array_uint128s_append__works),
cmocka_unit_test(test__f_type_array_uint128s_append_all__works),
#define CMOCKA_XML_FILE ./out.xml
main:
- build settings individual tests
+ build settings individual test
build settings-tests individual test
operate ld_library_path
projects / fll / commitdiff