From 1ef45af1eae1a4232425a0d468409eeff0ec3202 Mon Sep 17 00:00:00 2001
From: Kevin Day <Kevin@kevux.org>
Date: Sun, 19 Jan 2025 21:54:42 -0600
Subject: [PATCH] Cleanup: Fix function alphabetic ordering in unit tests.

Several of the test files have the parameter_checking function out of order.
I also happened to notice that the work test in some cases are also out of order.

This out of order is likely a problem caused by early day mass test generation.
---
 .../tests/unit/c/test-string-append.c         | 22 +++---
 .../tests/unit/c/test-string-append.h         |  8 +-
 .../tests/unit/c/test-string-append_assure.c  | 22 +++---
 .../tests/unit/c/test-string-append_assure.h  |  8 +-
 .../c/test-string-append_assure_nulless.c     | 22 +++---
 .../c/test-string-append_assure_nulless.h     |  8 +-
 .../tests/unit/c/test-string-append_nulless.c | 22 +++---
 .../tests/unit/c/test-string-append_nulless.h |  8 +-
 .../tests/unit/c/test-string-dynamic_append.c | 22 +++---
 .../tests/unit/c/test-string-dynamic_append.h |  8 +-
 .../c/test-string-dynamic_append_assure.c     | 22 +++---
 .../c/test-string-dynamic_append_assure.h     |  8 +-
 ...est-string-dynamic_append_assure_nulless.c | 22 +++---
 ...est-string-dynamic_append_assure_nulless.h |  8 +-
 .../c/test-string-dynamic_append_nulless.c    | 22 +++---
 .../c/test-string-dynamic_append_nulless.h    |  8 +-
 .../tests/unit/c/test-string-dynamic_mash.c   | 24 +++---
 .../tests/unit/c/test-string-dynamic_mash.h   |  8 +-
 .../unit/c/test-string-dynamic_mash_nulless.c | 24 +++---
 .../unit/c/test-string-dynamic_mash_nulless.h |  8 +-
 .../tests/unit/c/test-string-dynamic_mish.c   | 24 +++---
 .../tests/unit/c/test-string-dynamic_mish.h   |  8 +-
 .../unit/c/test-string-dynamic_mish_nulless.c | 24 +++---
 .../unit/c/test-string-dynamic_mish_nulless.h |  8 +-
 .../c/test-string-dynamic_partial_append.c    | 24 +++---
 .../c/test-string-dynamic_partial_append.h    |  8 +-
 ...est-string-dynamic_partial_append_assure.c | 24 +++---
 ...est-string-dynamic_partial_append_assure.h |  8 +-
 ...ng-dynamic_partial_append_assure_nulless.c | 24 +++---
 ...ng-dynamic_partial_append_assure_nulless.h |  8 +-
 ...st-string-dynamic_partial_append_nulless.c | 24 +++---
 ...st-string-dynamic_partial_append_nulless.h |  8 +-
 .../unit/c/test-string-dynamic_partial_mash.c | 26 +++----
 .../unit/c/test-string-dynamic_partial_mash.h |  8 +-
 ...test-string-dynamic_partial_mash_nulless.c | 26 +++----
 ...test-string-dynamic_partial_mash_nulless.h |  8 +-
 .../unit/c/test-string-dynamic_partial_mish.c | 26 +++----
 .../unit/c/test-string-dynamic_partial_mish.h |  9 ++-
 ...test-string-dynamic_partial_mish_nulless.c | 26 +++----
 ...test-string-dynamic_partial_mish_nulless.h |  8 +-
 .../c/test-string-dynamic_partial_prepend.c   | 24 +++---
 .../c/test-string-dynamic_partial_prepend.h   |  8 +-
 ...st-string-dynamic_partial_prepend_assure.c | 24 +++---
 ...st-string-dynamic_partial_prepend_assure.h |  8 +-
 ...g-dynamic_partial_prepend_assure_nulless.c | 24 +++---
 ...g-dynamic_partial_prepend_assure_nulless.h |  8 +-
 ...t-string-dynamic_partial_prepend_nulless.c | 24 +++---
 ...t-string-dynamic_partial_prepend_nulless.h |  8 +-
 .../unit/c/test-string-dynamic_prepend.c      | 22 +++---
 .../unit/c/test-string-dynamic_prepend.h      |  8 +-
 .../c/test-string-dynamic_prepend_assure.c    | 22 +++---
 .../c/test-string-dynamic_prepend_assure.h    |  8 +-
 ...st-string-dynamic_prepend_assure_nulless.c | 22 +++---
 ...st-string-dynamic_prepend_assure_nulless.h |  8 +-
 .../c/test-string-dynamic_prepend_nulless.c   | 22 +++---
 .../c/test-string-dynamic_prepend_nulless.h   |  8 +-
 .../unit/c/test-string-dynamic_seek_line.c    | 22 +++---
 .../unit/c/test-string-dynamic_seek_line.h    | 14 ++--
 .../unit/c/test-string-dynamic_seek_line_to.c | 24 +++---
 .../unit/c/test-string-dynamic_seek_line_to.h | 14 ++--
 .../unit/c/test-string-dynamic_seek_to.c      | 24 +++---
 .../unit/c/test-string-dynamic_seek_to.h      | 14 ++--
 .../unit/c/test-string-dynamic_strip_null.c   | 18 ++---
 .../unit/c/test-string-dynamic_strip_null.h   | 12 +--
 .../c/test-string-dynamic_strip_null_range.c  | 22 +++---
 .../c/test-string-dynamic_strip_null_range.h  | 14 ++--
 .../unit/c/test-string-dynamics_append.c      | 22 +++---
 .../unit/c/test-string-dynamics_append.h      |  8 +-
 .../unit/c/test-string-dynamics_append_all.c  | 74 +++++++++----------
 .../unit/c/test-string-dynamics_append_all.h  |  8 +-
 .../unit/c/test-string-dynamicss_append.c     | 74 +++++++++----------
 .../unit/c/test-string-dynamicss_append.h     |  8 +-
 .../unit/c/test-string-dynamicss_append_all.c | 74 +++++++++----------
 .../unit/c/test-string-dynamicss_append_all.h |  8 +-
 .../unit/c/test-string-map_multis_append.c    | 22 +++---
 .../unit/c/test-string-map_multis_append.h    |  8 +-
 .../c/test-string-map_multis_append_all.c     | 74 +++++++++----------
 .../c/test-string-map_multis_append_all.h     |  8 +-
 .../unit/c/test-string-map_multiss_append.c   | 74 +++++++++----------
 .../unit/c/test-string-map_multiss_append.h   |  8 +-
 .../c/test-string-map_multiss_append_all.c    | 74 +++++++++----------
 .../c/test-string-map_multiss_append_all.h    |  8 +-
 .../tests/unit/c/test-string-maps_append.c    | 22 +++---
 .../tests/unit/c/test-string-maps_append.h    |  8 +-
 .../unit/c/test-string-maps_append_all.c      | 74 +++++++++----------
 .../unit/c/test-string-maps_append_all.h      |  8 +-
 .../tests/unit/c/test-string-mapss_append.c   | 74 +++++++++----------
 .../tests/unit/c/test-string-mapss_append.h   |  8 +-
 .../unit/c/test-string-mapss_append_all.c     | 74 +++++++++----------
 .../unit/c/test-string-mapss_append_all.h     |  8 +-
 .../f_string/tests/unit/c/test-string-mash.c  | 24 +++---
 .../f_string/tests/unit/c/test-string-mash.h  |  8 +-
 .../tests/unit/c/test-string-mash_nulless.c   | 24 +++---
 .../tests/unit/c/test-string-mash_nulless.h   |  8 +-
 .../f_string/tests/unit/c/test-string-mish.c  | 24 +++---
 .../f_string/tests/unit/c/test-string-mish.h  |  8 +-
 .../tests/unit/c/test-string-mish_nulless.c   | 24 +++---
 .../tests/unit/c/test-string-mish_nulless.h   |  8 +-
 .../tests/unit/c/test-string-prepend.c        | 22 +++---
 .../tests/unit/c/test-string-prepend.h        |  8 +-
 .../tests/unit/c/test-string-prepend_assure.c | 22 +++---
 .../tests/unit/c/test-string-prepend_assure.h |  8 +-
 .../c/test-string-prepend_assure_nulless.c    | 22 +++---
 .../c/test-string-prepend_assure_nulless.h    |  8 +-
 .../unit/c/test-string-prepend_nulless.c      | 22 +++---
 .../unit/c/test-string-prepend_nulless.h      |  8 +-
 .../tests/unit/c/test-string-seek_line.c      | 22 +++---
 .../tests/unit/c/test-string-seek_line.h      | 14 ++--
 .../tests/unit/c/test-string-seek_line_to.c   | 24 +++---
 .../tests/unit/c/test-string-seek_line_to.h   | 14 ++--
 .../tests/unit/c/test-string-seek_to.c        | 24 +++---
 .../tests/unit/c/test-string-seek_to.h        | 14 ++--
 .../tests/unit/c/test-string-triples_append.c | 22 +++---
 .../tests/unit/c/test-string-triples_append.h |  8 +-
 .../unit/c/test-string-triples_append_all.c   | 74 +++++++++----------
 .../unit/c/test-string-triples_append_all.h   |  8 +-
 .../unit/c/test-string-tripless_append.c      | 74 +++++++++----------
 .../unit/c/test-string-tripless_append.h      |  8 +-
 .../unit/c/test-string-tripless_append_all.c  | 74 +++++++++----------
 .../unit/c/test-string-tripless_append_all.h  |  8 +-
 level_0/f_utf/tests/unit/c/test-utf-append.c  | 22 +++---
 level_0/f_utf/tests/unit/c/test-utf-append.h  |  8 +-
 .../tests/unit/c/test-utf-append_assure.c     | 22 +++---
 .../tests/unit/c/test-utf-append_assure.h     |  8 +-
 .../unit/c/test-utf-append_assure_nulless.c   | 22 +++---
 .../unit/c/test-utf-append_assure_nulless.h   |  8 +-
 .../tests/unit/c/test-utf-append_nulless.c    | 22 +++---
 .../tests/unit/c/test-utf-append_nulless.h    |  8 +-
 .../unit/c/test-utf-dynamic_append_assure.c   | 22 +++---
 .../unit/c/test-utf-dynamic_append_assure.h   |  8 +-
 .../test-utf-dynamic_append_assure_nulless.c  | 22 +++---
 .../test-utf-dynamic_append_assure_nulless.h  |  8 +-
 .../unit/c/test-utf-dynamic_append_nulless.c  | 22 +++---
 .../unit/c/test-utf-dynamic_append_nulless.h  |  8 +-
 .../tests/unit/c/test-utf-dynamic_mash.c      | 24 +++---
 .../tests/unit/c/test-utf-dynamic_mash.h      |  8 +-
 .../unit/c/test-utf-dynamic_mash_nulless.c    | 24 +++---
 .../unit/c/test-utf-dynamic_mash_nulless.h    |  8 +-
 .../tests/unit/c/test-utf-dynamic_mish.c      | 24 +++---
 .../tests/unit/c/test-utf-dynamic_mish.h      |  8 +-
 .../unit/c/test-utf-dynamic_mish_nulless.c    | 24 +++---
 .../unit/c/test-utf-dynamic_mish_nulless.h    |  8 +-
 .../unit/c/test-utf-dynamic_partial_append.c  | 24 +++---
 .../unit/c/test-utf-dynamic_partial_append.h  |  8 +-
 .../test-utf-dynamic_partial_append_assure.c  | 24 +++---
 .../test-utf-dynamic_partial_append_assure.h  |  8 +-
 ...tf-dynamic_partial_append_assure_nulless.c | 24 +++---
 ...tf-dynamic_partial_append_assure_nulless.h |  8 +-
 .../test-utf-dynamic_partial_append_nulless.c | 24 +++---
 .../test-utf-dynamic_partial_append_nulless.h |  8 +-
 .../unit/c/test-utf-dynamic_partial_mash.c    | 26 +++----
 .../unit/c/test-utf-dynamic_partial_mash.h    |  8 +-
 .../c/test-utf-dynamic_partial_mash_nulless.c | 26 +++----
 .../c/test-utf-dynamic_partial_mash_nulless.h |  8 +-
 .../unit/c/test-utf-dynamic_partial_mish.c    | 26 +++----
 .../unit/c/test-utf-dynamic_partial_mish.h    |  9 ++-
 .../c/test-utf-dynamic_partial_mish_nulless.c | 26 +++----
 .../c/test-utf-dynamic_partial_mish_nulless.h |  8 +-
 .../unit/c/test-utf-dynamic_partial_prepend.c | 24 +++---
 .../unit/c/test-utf-dynamic_partial_prepend.h |  8 +-
 .../test-utf-dynamic_partial_prepend_assure.c | 24 +++---
 .../test-utf-dynamic_partial_prepend_assure.h |  8 +-
 ...f-dynamic_partial_prepend_assure_nulless.c | 24 +++---
 ...f-dynamic_partial_prepend_assure_nulless.h |  8 +-
 ...test-utf-dynamic_partial_prepend_nulless.c | 24 +++---
 ...test-utf-dynamic_partial_prepend_nulless.h |  8 +-
 .../tests/unit/c/test-utf-dynamic_prepend.c   | 22 +++---
 .../tests/unit/c/test-utf-dynamic_prepend.h   |  8 +-
 .../unit/c/test-utf-dynamic_prepend_assure.c  | 22 +++---
 .../unit/c/test-utf-dynamic_prepend_assure.h  |  8 +-
 .../test-utf-dynamic_prepend_assure_nulless.c | 22 +++---
 .../test-utf-dynamic_prepend_assure_nulless.h |  8 +-
 .../unit/c/test-utf-dynamic_prepend_nulless.c | 22 +++---
 .../unit/c/test-utf-dynamic_prepend_nulless.h |  8 +-
 .../tests/unit/c/test-utf-dynamic_seek_line.c | 22 +++---
 .../tests/unit/c/test-utf-dynamic_seek_line.h | 14 ++--
 .../unit/c/test-utf-dynamic_seek_line_to.c    | 24 +++---
 .../unit/c/test-utf-dynamic_seek_line_to.h    | 14 ++--
 .../tests/unit/c/test-utf-dynamic_seek_to.c   | 24 +++---
 .../tests/unit/c/test-utf-dynamic_seek_to.h   | 14 ++--
 .../tests/unit/c/test-utf-dynamics_append.c   | 22 +++---
 .../tests/unit/c/test-utf-dynamics_append.h   |  8 +-
 .../unit/c/test-utf-dynamics_append_all.c     | 22 +++---
 .../unit/c/test-utf-dynamics_append_all.h     | 12 +--
 .../tests/unit/c/test-utf-dynamicss_append.c  | 74 +++++++++----------
 .../tests/unit/c/test-utf-dynamicss_append.h  |  8 +-
 .../unit/c/test-utf-dynamicss_append_all.c    | 74 +++++++++----------
 .../unit/c/test-utf-dynamicss_append_all.h    |  8 +-
 .../tests/unit/c/test-utf-map_multis_append.c | 22 +++---
 .../tests/unit/c/test-utf-map_multis_append.h |  8 +-
 .../unit/c/test-utf-map_multis_append_all.c   | 74 +++++++++----------
 .../unit/c/test-utf-map_multis_append_all.h   |  8 +-
 .../unit/c/test-utf-map_multiss_append.c      | 74 +++++++++----------
 .../unit/c/test-utf-map_multiss_append.h      |  8 +-
 .../unit/c/test-utf-map_multiss_append_all.c  | 74 +++++++++----------
 .../unit/c/test-utf-map_multiss_append_all.h  |  8 +-
 .../f_utf/tests/unit/c/test-utf-maps_append.c | 22 +++---
 .../f_utf/tests/unit/c/test-utf-maps_append.h |  8 +-
 .../tests/unit/c/test-utf-maps_append_all.c   | 74 +++++++++----------
 .../tests/unit/c/test-utf-maps_append_all.h   |  8 +-
 .../tests/unit/c/test-utf-mapss_append.c      | 74 +++++++++----------
 .../tests/unit/c/test-utf-mapss_append.h      |  8 +-
 .../tests/unit/c/test-utf-mapss_append_all.c  | 74 +++++++++----------
 .../tests/unit/c/test-utf-mapss_append_all.h  |  8 +-
 level_0/f_utf/tests/unit/c/test-utf-mash.c    | 24 +++---
 level_0/f_utf/tests/unit/c/test-utf-mash.h    |  8 +-
 .../tests/unit/c/test-utf-mash_nulless.c      | 24 +++---
 .../tests/unit/c/test-utf-mash_nulless.h      |  8 +-
 level_0/f_utf/tests/unit/c/test-utf-mish.c    | 24 +++---
 level_0/f_utf/tests/unit/c/test-utf-mish.h    |  8 +-
 .../tests/unit/c/test-utf-mish_nulless.c      | 24 +++---
 .../tests/unit/c/test-utf-mish_nulless.h      |  8 +-
 level_0/f_utf/tests/unit/c/test-utf-prepend.c | 22 +++---
 level_0/f_utf/tests/unit/c/test-utf-prepend.h |  8 +-
 .../tests/unit/c/test-utf-prepend_assure.c    | 22 +++---
 .../tests/unit/c/test-utf-prepend_assure.h    |  8 +-
 .../unit/c/test-utf-prepend_assure_nulless.c  | 22 +++---
 .../unit/c/test-utf-prepend_assure_nulless.h  |  8 +-
 .../tests/unit/c/test-utf-prepend_nulless.c   | 22 +++---
 .../tests/unit/c/test-utf-prepend_nulless.h   |  8 +-
 .../f_utf/tests/unit/c/test-utf-seek_line.c   | 22 +++---
 .../f_utf/tests/unit/c/test-utf-seek_line.h   | 14 ++--
 .../tests/unit/c/test-utf-seek_line_to.c      | 24 +++---
 .../tests/unit/c/test-utf-seek_line_to.h      | 12 +--
 level_0/f_utf/tests/unit/c/test-utf-seek_to.c | 24 +++---
 level_0/f_utf/tests/unit/c/test-utf-seek_to.h | 12 +--
 .../tests/unit/c/test-utf-triples_append.c    | 22 +++---
 .../tests/unit/c/test-utf-triples_append.h    |  8 +-
 .../unit/c/test-utf-triples_append_all.c      | 74 +++++++++----------
 .../unit/c/test-utf-triples_append_all.h      |  8 +-
 .../tests/unit/c/test-utf-tripless_append.c   | 74 +++++++++----------
 .../tests/unit/c/test-utf-tripless_append.h   |  8 +-
 .../unit/c/test-utf-tripless_append_all.c     | 74 +++++++++----------
 .../unit/c/test-utf-tripless_append_all.h     |  8 +-
 234 files changed, 2450 insertions(+), 2448 deletions(-)

diff --git a/level_0/f_string/tests/unit/c/test-string-append.c b/level_0/f_string/tests/unit/c/test-string-append.c
index a23968040..f0dd4e86a 100644
--- a/level_0/f_string/tests/unit/c/test-string-append.c
+++ b/level_0/f_string/tests/unit/c/test-string-append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_append__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_append(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_append__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_append__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_append__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_append(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-append.h b/level_0/f_string/tests/unit/c/test-string-append.h
index 2ee97dcde..247fefbca 100644
--- a/level_0/f_string/tests/unit/c/test-string-append.h
+++ b/level_0/f_string/tests/unit/c/test-string-append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_append()
  */
-extern void test__f_string_append__works(void **state);
+extern void test__f_string_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_append()
  */
-extern void test__f_string_append__parameter_checking(void **state);
+extern void test__f_string_append__works(void **state);
 
 #endif // _TEST__F_string_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-append_assure.c b/level_0/f_string/tests/unit/c/test-string-append_assure.c
index ce2407d25..b7f3c1b69 100644
--- a/level_0/f_string/tests/unit/c/test-string-append_assure.c
+++ b/level_0/f_string/tests/unit/c/test-string-append_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_append_assure__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_append_assure(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_append_assure__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -34,17 +45,6 @@ void test__f_string_append_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_append_assure__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_append_assure(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-append_assure.h b/level_0/f_string/tests/unit/c/test-string-append_assure.h
index 02d75afb1..3b94e5a0b 100644
--- a/level_0/f_string/tests/unit/c/test-string-append_assure.h
+++ b/level_0/f_string/tests/unit/c/test-string-append_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_append_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_append_assure()
  */
-extern void test__f_string_append_assure__works(void **state);
+extern void test__f_string_append_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_append_assure()
  */
-extern void test__f_string_append_assure__parameter_checking(void **state);
+extern void test__f_string_append_assure__works(void **state);
 
 #endif // _TEST__F_string_append_assure_h
diff --git a/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.c b/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.c
index 41c2d0774..6cd2b73b2 100644
--- a/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_append_assure_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_append_assure_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_append_assure_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -33,17 +44,6 @@ void test__f_string_append_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_append_assure_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_append_assure_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.h b/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.h
index 8c72b30a8..0371eae69 100644
--- a/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-append_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_append_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_append_assure_nulless()
  */
-extern void test__f_string_append_assure_nulless__works(void **state);
+extern void test__f_string_append_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_append_assure_nulless()
  */
-extern void test__f_string_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_append_assure_nulless__works(void **state);
 
 #endif // _TEST__F_string_append_assure_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-append_nulless.c b/level_0/f_string/tests/unit/c/test-string-append_nulless.c
index 479b9504c..ee4f8e3a0 100644
--- a/level_0/f_string/tests/unit/c/test-string-append_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-append_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_append_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_append_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_append_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_append_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_append_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_append_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-append_nulless.h b/level_0/f_string/tests/unit/c/test-string-append_nulless.h
index 7d1bf2076..db684477d 100644
--- a/level_0/f_string/tests/unit/c/test-string-append_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-append_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_append_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_append_nulless()
  */
-extern void test__f_string_append_nulless__works(void **state);
+extern void test__f_string_append_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_append_nulless()
  */
-extern void test__f_string_append_nulless__parameter_checking(void **state);
+extern void test__f_string_append_nulless__works(void **state);
 
 #endif // _TEST__F_string_append_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append.c b/level_0/f_string/tests/unit/c/test-string-dynamic_append.c
index 0f0d5446a..4f0aebfb1 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_append__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_append__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_dynamic_append__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_append__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append.h b/level_0/f_string/tests/unit/c/test-string-dynamic_append.h
index a89a35e9c..a2f8186d5 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_append()
  */
-extern void test__f_string_dynamic_append__works(void **state);
+extern void test__f_string_dynamic_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_append()
  */
-extern void test__f_string_dynamic_append__parameter_checking(void **state);
+extern void test__f_string_dynamic_append__works(void **state);
 
 #endif // _TEST__F_string_dynamic_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.c b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.c
index 511d85a38..8939501fd 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_append_assure__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_append_assure(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_append_assure__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -34,17 +45,6 @@ void test__f_string_dynamic_append_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_append_assure__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_append_assure(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.h b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.h
index 72d945779..b3fa05d57 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_append_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_append_assure()
  */
-extern void test__f_string_dynamic_append_assure__works(void **state);
+extern void test__f_string_dynamic_append_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_append_assure()
  */
-extern void test__f_string_dynamic_append_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_append_assure__works(void **state);
 
 #endif // _TEST__F_string_dynamic_append_assure_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.c
index e94ac931a..e5d6eefda 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_append_assure_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_append_assure_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -33,17 +44,6 @@ void test__f_string_dynamic_append_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_append_assure_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.h
index 83a7097d6..b6ff3485c 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_append_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_append_assure_nulless()
  */
-extern void test__f_string_dynamic_append_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_append_assure_nulless()
  */
-extern void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_append_assure_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_append_assure_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.c
index 48e24e0e8..c5bc6beca 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_append_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_append_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_append_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_dynamic_append_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_append_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_append_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.h
index 5942a5f22..fd1b00680 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_append_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_append_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_append_nulless()
  */
-extern void test__f_string_dynamic_append_nulless__works(void **state);
+extern void test__f_string_dynamic_append_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_append_nulless()
  */
-extern void test__f_string_dynamic_append_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_append_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_append_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mash.c b/level_0/f_string/tests/unit/c/test-string-dynamic_mash.c
index 4a3ad7e66..ac20a5e63 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mash.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mash.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_mash__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_dynamic_mash(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_mash__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -37,18 +49,6 @@ void test__f_string_dynamic_mash__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_mash__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_dynamic_mash(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mash.h b/level_0/f_string/tests/unit/c/test-string-dynamic_mash.h
index c92487d3d..480cd39ef 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mash.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mash.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_mash_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_mash()
  */
-extern void test__f_string_dynamic_mash__works(void **state);
+extern void test__f_string_dynamic_mash__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_mash()
  */
-extern void test__f_string_dynamic_mash__parameter_checking(void **state);
+extern void test__f_string_dynamic_mash__works(void **state);
 
 #endif // _TEST__F_string_dynamic_mash_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.c
index 6aaaba3f5..aa7f15401 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_mash_nulless__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_dynamic_mash_nulless(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_mash_nulless__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -35,18 +47,6 @@ void test__f_string_dynamic_mash_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_mash_nulless__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_dynamic_mash_nulless(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.h
index 47440974f..5d7146f0e 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mash_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_mash_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_mash_nulless()
  */
-extern void test__f_string_dynamic_mash_nulless__works(void **state);
+extern void test__f_string_dynamic_mash_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_mash_nulless()
  */
-extern void test__f_string_dynamic_mash_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_mash_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_mash_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mish.c b/level_0/f_string/tests/unit/c/test-string-dynamic_mish.c
index 7df910b0e..2428175ae 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mish.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mish.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_mish__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_dynamic_mish(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_mish__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -37,18 +49,6 @@ void test__f_string_dynamic_mish__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_mish__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_dynamic_mish(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mish.h b/level_0/f_string/tests/unit/c/test-string-dynamic_mish.h
index ba3ebde39..d99b0154e 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mish.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mish.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_mish_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_mish()
  */
-extern void test__f_string_dynamic_mish__works(void **state);
+extern void test__f_string_dynamic_mish__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_mish()
  */
-extern void test__f_string_dynamic_mish__parameter_checking(void **state);
+extern void test__f_string_dynamic_mish__works(void **state);
 
 #endif // _TEST__F_string_dynamic_mish_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.c
index 42ee63547..911e07553 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_mish_nulless__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_dynamic_mish_nulless(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_mish_nulless__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -35,18 +47,6 @@ void test__f_string_dynamic_mish_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_mish_nulless__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_dynamic_mish_nulless(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.h
index f3745b074..edcec8a5d 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_mish_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_mish_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_mish_nulless()
  */
-extern void test__f_string_dynamic_mish_nulless__works(void **state);
+extern void test__f_string_dynamic_mish_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_mish_nulless()
  */
-extern void test__f_string_dynamic_mish_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_mish_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_mish_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.c
index 2e3a44ae8..a29827fe1 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_append__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_append(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_append__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -25,18 +37,6 @@ void test__f_string_dynamic_partial_append__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_append__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_append(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.h
index 8bb8cdc36..538b8050f 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_append()
  */
-extern void test__f_string_dynamic_partial_append__works(void **state);
+extern void test__f_string_dynamic_partial_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_append()
  */
-extern void test__f_string_dynamic_partial_append__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.c
index 67a96f3c3..67f510a2b 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_append_assure(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_append_assure__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -36,18 +48,6 @@ void test__f_string_dynamic_partial_append_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_append_assure(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.h
index e8e6bf443..23e5eef06 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_append_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_append_assure()
  */
-extern void test__f_string_dynamic_partial_append_assure__works(void **state);
+extern void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_append_assure()
  */
-extern void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append_assure__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_append_assure_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.c
index b3d555af2..2e9463b20 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_append_assure_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_append_assure_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -34,18 +46,6 @@ void test__f_string_dynamic_partial_append_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_append_assure_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.h
index c46708cee..b2a765488 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_append_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_append_assure_nulless()
  */
-extern void test__f_string_dynamic_partial_append_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_append_assure_nulless()
  */
-extern void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append_assure_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_append_assure_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.c
index 01d864fb7..56d643445 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_append_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_append_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -24,18 +36,6 @@ void test__f_string_dynamic_partial_append_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_append_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.h
index ddd85fc70..0b90780a4 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_append_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_append_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_append_nulless()
  */
-extern void test__f_string_dynamic_partial_append_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_append_nulless()
  */
-extern void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_append_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.c
index fb357b3c0..3de508539 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_mash__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_mash(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_mash__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -39,19 +52,6 @@ void test__f_string_dynamic_partial_mash__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_mash__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_mash(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.h
index 0629f3d98..20a2649b9 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_mash_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_mash()
  */
-extern void test__f_string_dynamic_partial_mash__works(void **state);
+extern void test__f_string_dynamic_partial_mash__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_mash()
  */
-extern void test__f_string_dynamic_partial_mash__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mash__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_mash_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.c
index 0e8428d4c..953017a13 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_mash_nulless__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -36,19 +49,6 @@ void test__f_string_dynamic_partial_mash_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.h
index 838fd0508..25d1f9c2d 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mash_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_mash_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_mash_nulless()
  */
-extern void test__f_string_dynamic_partial_mash_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_mash_nulless()
  */
-extern void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mash_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_mash_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.c
index f83dfe0f6..f8de2b726 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_mish__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_mish(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_mish__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -39,19 +52,6 @@ void test__f_string_dynamic_partial_mish__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_mish__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_mish(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.h
index 5e2795719..5ce563fbf 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish.h
@@ -11,16 +11,17 @@
 #define _TEST__F_string_dynamic_partial_mish_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_mish()
  */
-extern void test__f_string_dynamic_partial_mish__works(void **state);
+extern void test__f_string_dynamic_partial_mish__parameter_checking(void **state);
+
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_mish()
  */
-extern void test__f_string_dynamic_partial_mish__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mish__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_mish_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.c
index 9c1afe731..c68956613 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_mish_nulless__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -36,19 +49,6 @@ void test__f_string_dynamic_partial_mish_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.h
index 29b02ec19..915f67727 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_mish_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_mish_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_mish_nulless()
  */
-extern void test__f_string_dynamic_partial_mish_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_mish_nulless()
  */
-extern void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mish_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_mish_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.c
index decba43da..5ac7118c1 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_prepend__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_prepend(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_prepend__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -25,18 +37,6 @@ void test__f_string_dynamic_partial_prepend__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_prepend__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_prepend(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.h
index 891ac0702..6b0cb2dcc 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_prepend_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_prepend()
  */
-extern void test__f_string_dynamic_partial_prepend__works(void **state);
+extern void test__f_string_dynamic_partial_prepend__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_prepend()
  */
-extern void test__f_string_dynamic_partial_prepend__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_prepend_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.c
index fa9c6ef64..33d15c3e5 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_prepend_assure(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_prepend_assure__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -36,18 +48,6 @@ void test__f_string_dynamic_partial_prepend_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_prepend_assure(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.h
index 032c3b2d1..f6dffe4ff 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_prepend_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_prepend_assure()
  */
-extern void test__f_string_dynamic_partial_prepend_assure__works(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_prepend_assure()
  */
-extern void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_prepend_assure_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.c
index ccdaed346..d00e88501 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -34,18 +46,6 @@ void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state)
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.h
index 9139e1da0..cf025bc89 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_prepend_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_prepend_assure_nulless()
  */
-extern void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_prepend_assure_nulless()
  */
-extern void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_prepend_assure_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.c
index ab6119383..f13bee34f 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_partial_prepend_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_partial_prepend_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
@@ -24,18 +36,6 @@ void test__f_string_dynamic_partial_prepend_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_partial_prepend_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.h
index f857f4e9c..c480fe4d5 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_partial_prepend_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_partial_prepend_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_partial_prepend_nulless()
  */
-extern void test__f_string_dynamic_partial_prepend_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_partial_prepend_nulless()
  */
-extern void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_partial_prepend_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.c b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.c
index 9564944b2..16a5fd6fa 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_prepend__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_prepend(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_prepend__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_dynamic_prepend__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_prepend__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_prepend(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.h b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.h
index a27fc2a65..abb086398 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_prepend_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_prepend()
  */
-extern void test__f_string_dynamic_prepend__works(void **state);
+extern void test__f_string_dynamic_prepend__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_prepend()
  */
-extern void test__f_string_dynamic_prepend__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend__works(void **state);
 
 #endif // _TEST__F_string_dynamic_prepend_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.c b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.c
index c98cd2440..766bd8656 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_prepend_assure__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_prepend_assure(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_prepend_assure__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -34,17 +45,6 @@ void test__f_string_dynamic_prepend_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_prepend_assure__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_prepend_assure(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.h b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.h
index 5014d376e..2be89d3d9 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_prepend_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_prepend_assure()
  */
-extern void test__f_string_dynamic_prepend_assure__works(void **state);
+extern void test__f_string_dynamic_prepend_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_prepend_assure()
  */
-extern void test__f_string_dynamic_prepend_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend_assure__works(void **state);
 
 #endif // _TEST__F_string_dynamic_prepend_assure_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.c
index c85fa8276..9e6f29ce8 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_prepend_assure_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_prepend_assure_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -33,17 +44,6 @@ void test__f_string_dynamic_prepend_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_prepend_assure_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.h
index 62d99d0b4..65d2ebeef 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_prepend_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_prepend_assure_nulless()
  */
-extern void test__f_string_dynamic_prepend_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_prepend_assure_nulless()
  */
-extern void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend_assure_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_prepend_assure_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.c b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.c
index 3a2f60023..30a344b86 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_prepend_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_prepend_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_dynamic_prepend_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_prepend_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.h b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.h
index f1f7d3a96..b6b5724c8 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_prepend_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamic_prepend_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_prepend_nulless()
  */
-extern void test__f_string_dynamic_prepend_nulless__works(void **state);
+extern void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_prepend_nulless()
  */
-extern void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend_nulless__works(void **state);
 
 #endif // _TEST__F_string_dynamic_prepend_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.c b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.c
index 1ab687a9c..00c335081 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_seek_line__parameter_checking(void **state) {
+
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+  {
+    const f_status_t status = f_string_dynamic_seek_line(source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_seek_line__returns_data_not_stop(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("test\nafter", 0, 10);
@@ -66,17 +77,6 @@ void test__f_string_dynamic_seek_line__works(void **state) {
   }
 }
 
-void test__f_string_dynamic_seek_line__parameter_checking(void **state) {
-
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
-  {
-    const f_status_t status = f_string_dynamic_seek_line(source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.h b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.h
index aaaf36a92..a90c1cef5 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_string_dynamic_seek_line_h
 #define _TEST__F_string_dynamic_seek_line_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_seek_line()
+ */
+extern void test__f_string_dynamic_seek_line__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -38,11 +45,4 @@ extern void test__f_string_dynamic_seek_line__returns_none_stop(void **state);
  */
 extern void test__f_string_dynamic_seek_line__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_seek_line()
- */
-extern void test__f_string_dynamic_seek_line__parameter_checking(void **state);
-
 #endif // _TEST__F_string_dynamic_seek_line_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.c b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.c
index 6141525c4..cdd1f87d4 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.c
@@ -22,6 +22,18 @@ void test__f_string_dynamic_seek_line_to__at_newline(void **state) {
   }
 }
 
+void test__f_string_dynamic_seek_line_to__parameter_checking(void **state) {
+
+  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+  {
+    const f_status_t status = f_string_dynamic_seek_line_to(source, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_seek_line_to__returns_data_not_stop(void **state) {
 
   const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
@@ -87,18 +99,6 @@ void test__f_string_dynamic_seek_line_to__works(void **state) {
   }
 }
 
-void test__f_string_dynamic_seek_line_to__parameter_checking(void **state) {
-
-  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
-  {
-    const f_status_t status = f_string_dynamic_seek_line_to(source, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.h b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.h
index a23583106..b98b03e23 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_line_to.h
@@ -17,6 +17,13 @@
  */
 extern void test__f_string_dynamic_seek_line_to__at_newline(void **state);
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_seek_line_to()
+ */
+extern void test__f_string_dynamic_seek_line_to__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -45,11 +52,4 @@ extern void test__f_string_dynamic_seek_line_to__returns_none_stop(void **state)
  */
 extern void test__f_string_dynamic_seek_line_to__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_seek_line_to()
- */
-extern void test__f_string_dynamic_seek_line_to__parameter_checking(void **state);
-
 #endif // _TEST__F_string_dynamic_seek_line_to_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.c b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.c
index b2e9d5199..b0b2b88a1 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_seek_to__parameter_checking(void **state) {
+
+  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+  {
+    const f_status_t status = f_string_dynamic_seek_to(source, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_seek_to__returns_data_not_stop(void **state) {
 
   const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
@@ -70,18 +82,6 @@ void test__f_string_dynamic_seek_to__works(void **state) {
   }
 }
 
-void test__f_string_dynamic_seek_to__parameter_checking(void **state) {
-
-  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
-  {
-    const f_status_t status = f_string_dynamic_seek_to(source, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.h b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.h
index 042d64e6d..c05be09ce 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_seek_to.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_string_dynamic_seek_to_h
 #define _TEST__F_string_dynamic_seek_to_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_seek_to()
+ */
+extern void test__f_string_dynamic_seek_to__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -38,11 +45,4 @@ extern void test__f_string_dynamic_seek_to__returns_none_stop(void **state);
  */
 extern void test__f_string_dynamic_seek_to__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_seek_to()
- */
-extern void test__f_string_dynamic_seek_to__parameter_checking(void **state);
-
 #endif // _TEST__F_string_dynamic_seek_to_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.c b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.c
index 3e5eac839..abb05026c 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.c
@@ -5,6 +5,15 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_strip_null__parameter_checking(void **state) {
+
+  {
+    const f_status_t status = f_string_dynamic_strip_null(0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_strip_null__returns_data_not(void **state) {
 
   f_string_static_t buffer = f_string_static_t_initialize;
@@ -127,15 +136,6 @@ void test__f_string_dynamic_strip_null__works(void **state) {
   } // for
 }
 
-void test__f_string_dynamic_strip_null__parameter_checking(void **state) {
-
-  {
-    const f_status_t status = f_string_dynamic_strip_null(0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.h b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.h
index 35d05d576..2ea815d43 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null.h
@@ -11,24 +11,24 @@
 #define _TEST__F_dynamic_strip_null_h
 
 /**
- * Test that the function returns F_data_not because the buffer is empty.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamic_strip_null()
  */
-extern void test__f_string_dynamic_strip_null__returns_data_not(void **state);
+extern void test__f_string_dynamic_strip_null__parameter_checking(void **state);
 
 /**
- * Test that the function works.
+ * Test that the function returns F_data_not because the buffer is empty.
  *
  * @see f_string_dynamic_strip_null()
  */
-extern void test__f_string_dynamic_strip_null__works(void **state);
+extern void test__f_string_dynamic_strip_null__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamic_strip_null()
  */
-extern void test__f_string_dynamic_strip_null__parameter_checking(void **state);
+extern void test__f_string_dynamic_strip_null__works(void **state);
 
 #endif // _TEST__F_dynamic_strip_null_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.c b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.c
index 180b3191c..2ff250cd2 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamic_strip_null_range__parameter_checking(void **state) {
+
+  const f_range_t range = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamic_strip_null_range(range, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamic_strip_null_range__returns_data_not(void **state) {
 
   f_string_static_t buffer = f_string_static_t_initialize;
@@ -197,17 +208,6 @@ void test__f_string_dynamic_strip_null_range__works(void **state) {
   } // for
 }
 
-void test__f_string_dynamic_strip_null_range__parameter_checking(void **state) {
-
-  const f_range_t range = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamic_strip_null_range(range, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.h b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.h
index 8e73f9312..073b9c609 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamic_strip_null_range.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_dynamic_strip_null_range_h
 #define _TEST__F_dynamic_strip_null_range_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_strip_null_range()
+ */
+extern void test__f_string_dynamic_strip_null_range__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not because the buffer is empty.
  *
@@ -38,11 +45,4 @@ extern void test__f_string_dynamic_strip_null_range__returns_data_not_stop(void
  */
 extern void test__f_string_dynamic_strip_null_range__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_strip_null_range()
- */
-extern void test__f_string_dynamic_strip_null_range__parameter_checking(void **state);
-
 #endif // _TEST__F_dynamic_strip_null_range_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamics_append.c b/level_0/f_string/tests/unit/c/test-string-dynamics_append.c
index 9c564c41b..d57aa5a3d 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamics_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamics_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamics_append__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamics_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_dynamics_append__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -25,17 +36,6 @@ void test__f_string_dynamics_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_dynamics_append__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamics_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamics_append.h b/level_0/f_string/tests/unit/c/test-string-dynamics_append.h
index e4d6f3fe6..9c559a8a9 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamics_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamics_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_dynamics_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamics_append()
  */
-extern void test__f_string_dynamics_append__works(void **state);
+extern void test__f_string_dynamics_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamics_append()
  */
-extern void test__f_string_dynamics_append__parameter_checking(void **state);
+extern void test__f_string_dynamics_append__works(void **state);
 
 #endif // _TEST__F_string_dynamics_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.c b/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.c
index ead76404c..e65479bba 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamics_append_all__parameter_checking(void **state) {
+
+  const f_string_dynamics_t data = f_string_dynamics_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamics_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_dynamics_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_dynamics_t source = f_string_dynamics_t_initialize;
+  f_string_dynamics_t destination = f_string_dynamics_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_dynamics_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_dynamics_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -61,43 +98,6 @@ void test__f_string_dynamics_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_dynamics_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_dynamics_t source = f_string_dynamics_t_initialize;
-  f_string_dynamics_t destination = f_string_dynamics_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_dynamics_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_dynamics_append_all__parameter_checking(void **state) {
-
-  const f_string_dynamics_t data = f_string_dynamics_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamics_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.h b/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.h
index 22d0f5fce..d1157592d 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamics_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_dynamics_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamics_append_all()
  */
-extern void test__f_string_dynamics_append_all__works(void **state);
+extern void test__f_string_dynamics_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_dynamics_append_all__works(void **state);
 extern void test__f_string_dynamics_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamics_append_all()
  */
-extern void test__f_string_dynamics_append_all__parameter_checking(void **state);
+extern void test__f_string_dynamics_append_all__works(void **state);
 
 #endif // _TEST__F_string_dynamics_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamicss_append.c b/level_0/f_string/tests/unit/c/test-string-dynamicss_append.c
index 9e17da4ff..d7d654bac 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamicss_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamicss_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamicss_append__parameter_checking(void **state) {
+
+  f_string_dynamics_t data = f_string_dynamics_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamicss_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_dynamicss_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_dynamics_t source = f_string_dynamicss_t_initialize;
+  f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_dynamicss_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_dynamicss_append__works(void **state) {
 
   const int length_inner = 2;
@@ -60,43 +97,6 @@ void test__f_string_dynamicss_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_dynamicss_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_dynamics_t source = f_string_dynamicss_t_initialize;
-  f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_dynamicss_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_dynamicss_append__parameter_checking(void **state) {
-
-  f_string_dynamics_t data = f_string_dynamics_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamicss_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamicss_append.h b/level_0/f_string/tests/unit/c/test-string-dynamicss_append.h
index f5a2bb44e..92af808f6 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamicss_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamicss_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_dynamicss_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamicss_append()
  */
-extern void test__f_string_dynamicss_append__works(void **state);
+extern void test__f_string_dynamicss_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_dynamicss_append__works(void **state);
 extern void test__f_string_dynamicss_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamicss_append()
  */
-extern void test__f_string_dynamicss_append__parameter_checking(void **state);
+extern void test__f_string_dynamicss_append__works(void **state);
 
 #endif // _TEST__F_string_dynamicss_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.c b/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.c
index f42dd3243..7c08f2442 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_dynamicss_append_all__parameter_checking(void **state) {
+
+  const f_string_dynamicss_t data = f_string_dynamicss_t_initialize;
+
+  {
+    const f_status_t status = f_string_dynamicss_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_dynamicss_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_dynamicss_t source = f_string_dynamicss_t_initialize;
+  f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamics_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamicss_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_dynamicss_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_dynamicss_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -86,43 +123,6 @@ void test__f_string_dynamicss_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_dynamicss_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_dynamicss_t source = f_string_dynamicss_t_initialize;
-  f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamics_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamicss_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_dynamicss_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_dynamicss_append_all__parameter_checking(void **state) {
-
-  const f_string_dynamicss_t data = f_string_dynamicss_t_initialize;
-
-  {
-    const f_status_t status = f_string_dynamicss_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.h b/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.h
index eca0be53f..1c26cb1af 100644
--- a/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-dynamicss_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_dynamicss_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_dynamicss_append_all()
  */
-extern void test__f_string_dynamicss_append_all__works(void **state);
+extern void test__f_string_dynamicss_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_dynamicss_append_all__works(void **state);
 extern void test__f_string_dynamicss_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_dynamicss_append_all()
  */
-extern void test__f_string_dynamicss_append_all__parameter_checking(void **state);
+extern void test__f_string_dynamicss_append_all__works(void **state);
 
 #endif // _TEST__F_string_dynamicss_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multis_append.c b/level_0/f_string/tests/unit/c/test-string-map_multis_append.c
index 54c43cb60..a71d623c9 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multis_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-map_multis_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_map_multis_append__parameter_checking(void **state) {
+
+  const f_string_map_multi_t data = f_string_map_multi_t_initialize;
+
+  {
+    const f_status_t status = f_string_map_multis_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_map_multis_append__works(void **state) {
 
   const int length_values = 2;
@@ -65,17 +76,6 @@ void test__f_string_map_multis_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_map_multis_append__parameter_checking(void **state) {
-
-  const f_string_map_multi_t data = f_string_map_multi_t_initialize;
-
-  {
-    const f_status_t status = f_string_map_multis_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multis_append.h b/level_0/f_string/tests/unit/c/test-string-map_multis_append.h
index 84441f3e9..bfec4204a 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multis_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-map_multis_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_map_multis_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_map_multis_append()
  */
-extern void test__f_string_map_multis_append__works(void **state);
+extern void test__f_string_map_multis_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_map_multis_append()
  */
-extern void test__f_string_map_multis_append__parameter_checking(void **state);
+extern void test__f_string_map_multis_append__works(void **state);
 
 #endif // _TEST__F_string_map_multis_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.c b/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.c
index fedc2fb79..4b6ab91f6 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_map_multis_append_all__parameter_checking(void **state) {
+
+  const f_string_map_multis_t data = f_string_map_multis_t_initialize;
+
+  {
+    const f_status_t status = f_string_map_multis_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_map_multis_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_map_multis_t source = f_string_map_multis_t_initialize;
+  f_string_map_multis_t destination = f_string_map_multis_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_map_multis_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_map_multis_append_all__works(void **state) {
 
   const int length_values = 2;
@@ -84,43 +121,6 @@ void test__f_string_map_multis_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_map_multis_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_map_multis_t source = f_string_map_multis_t_initialize;
-  f_string_map_multis_t destination = f_string_map_multis_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_map_multis_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_map_multis_append_all__parameter_checking(void **state) {
-
-  const f_string_map_multis_t data = f_string_map_multis_t_initialize;
-
-  {
-    const f_status_t status = f_string_map_multis_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.h b/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.h
index 858a94fa4..9a6eca5ad 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-map_multis_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_map_multis_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_map_multis_append_all()
  */
-extern void test__f_string_map_multis_append_all__works(void **state);
+extern void test__f_string_map_multis_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_map_multis_append_all__works(void **state);
 extern void test__f_string_map_multis_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_map_multis_append_all()
  */
-extern void test__f_string_map_multis_append_all__parameter_checking(void **state);
+extern void test__f_string_map_multis_append_all__works(void **state);
 
 #endif // _TEST__F_string_map_multis_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multiss_append.c b/level_0/f_string/tests/unit/c/test-string-map_multiss_append.c
index 46a816a46..6f2d7b66f 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multiss_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-map_multiss_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_map_multiss_append__parameter_checking(void **state) {
+
+  f_string_map_multis_t data = f_string_map_multis_t_initialize;
+
+  {
+    const f_status_t status = f_string_map_multiss_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_map_multiss_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_map_multis_t source = f_string_map_multiss_t_initialize;
+  f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_map_multiss_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_map_multiss_append__works(void **state) {
 
   const int length_values = 2;
@@ -99,43 +136,6 @@ void test__f_string_map_multiss_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_map_multiss_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_map_multis_t source = f_string_map_multiss_t_initialize;
-  f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_map_multiss_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_map_multiss_append__parameter_checking(void **state) {
-
-  f_string_map_multis_t data = f_string_map_multis_t_initialize;
-
-  {
-    const f_status_t status = f_string_map_multiss_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multiss_append.h b/level_0/f_string/tests/unit/c/test-string-map_multiss_append.h
index 5c7dbbcdb..d1fad5f49 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multiss_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-map_multiss_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_map_multiss_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_map_multiss_append()
  */
-extern void test__f_string_map_multiss_append__works(void **state);
+extern void test__f_string_map_multiss_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_map_multiss_append__works(void **state);
 extern void test__f_string_map_multiss_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_map_multiss_append()
  */
-extern void test__f_string_map_multiss_append__parameter_checking(void **state);
+extern void test__f_string_map_multiss_append__works(void **state);
 
 #endif // _TEST__F_string_map_multiss_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.c b/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.c
index aa081f758..6fad95183 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_map_multiss_append_all__parameter_checking(void **state) {
+
+  const f_string_map_multiss_t data = f_string_map_multiss_t_initialize;
+
+  {
+    const f_status_t status = f_string_map_multiss_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_map_multiss_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_map_multiss_t source = f_string_map_multiss_t_initialize;
+  f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multis_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multiss_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_map_multiss_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_map_multiss_append_all__works(void **state) {
 
   const int length_values = 2;
@@ -125,43 +162,6 @@ void test__f_string_map_multiss_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_map_multiss_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_map_multiss_t source = f_string_map_multiss_t_initialize;
-  f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multis_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multiss_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_map_multiss_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_map_multiss_append_all__parameter_checking(void **state) {
-
-  const f_string_map_multiss_t data = f_string_map_multiss_t_initialize;
-
-  {
-    const f_status_t status = f_string_map_multiss_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.h b/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.h
index da35a9e14..03c49a674 100644
--- a/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-map_multiss_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_map_multiss_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_map_multiss_append_all()
  */
-extern void test__f_string_map_multiss_append_all__works(void **state);
+extern void test__f_string_map_multiss_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_map_multiss_append_all__works(void **state);
 extern void test__f_string_map_multiss_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_map_multiss_append_all()
  */
-extern void test__f_string_map_multiss_append_all__parameter_checking(void **state);
+extern void test__f_string_map_multiss_append_all__works(void **state);
 
 #endif // _TEST__F_string_map_multiss_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-maps_append.c b/level_0/f_string/tests/unit/c/test-string-maps_append.c
index 19a42c52d..02f2c6670 100644
--- a/level_0/f_string/tests/unit/c/test-string-maps_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-maps_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_maps_append__parameter_checking(void **state) {
+
+  const f_string_map_t data = f_string_map_t_initialize;
+
+  {
+    const f_status_t status = f_string_maps_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_maps_append__works(void **state) {
 
   f_string_map_t source = f_string_map_t_initialize;
@@ -47,17 +58,6 @@ void test__f_string_maps_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_maps_append__parameter_checking(void **state) {
-
-  const f_string_map_t data = f_string_map_t_initialize;
-
-  {
-    const f_status_t status = f_string_maps_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-maps_append.h b/level_0/f_string/tests/unit/c/test-string-maps_append.h
index 0a04a3c64..0dfed2e4e 100644
--- a/level_0/f_string/tests/unit/c/test-string-maps_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-maps_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_maps_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_maps_append()
  */
-extern void test__f_string_maps_append__works(void **state);
+extern void test__f_string_maps_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_maps_append()
  */
-extern void test__f_string_maps_append__parameter_checking(void **state);
+extern void test__f_string_maps_append__works(void **state);
 
 #endif // _TEST__F_string_maps_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-maps_append_all.c b/level_0/f_string/tests/unit/c/test-string-maps_append_all.c
index a272a451a..1e3a86433 100644
--- a/level_0/f_string/tests/unit/c/test-string-maps_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-maps_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_maps_append_all__parameter_checking(void **state) {
+
+  const f_string_maps_t data = f_string_maps_t_initialize;
+
+  {
+    const f_status_t status = f_string_maps_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_maps_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_maps_t source = f_string_maps_t_initialize;
+  f_string_maps_t destination = f_string_maps_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_maps_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_maps_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -69,43 +106,6 @@ void test__f_string_maps_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_maps_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_maps_t source = f_string_maps_t_initialize;
-  f_string_maps_t destination = f_string_maps_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_maps_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_maps_append_all__parameter_checking(void **state) {
-
-  const f_string_maps_t data = f_string_maps_t_initialize;
-
-  {
-    const f_status_t status = f_string_maps_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-maps_append_all.h b/level_0/f_string/tests/unit/c/test-string-maps_append_all.h
index 9975c9ea4..f17de6739 100644
--- a/level_0/f_string/tests/unit/c/test-string-maps_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-maps_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_maps_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_maps_append_all()
  */
-extern void test__f_string_maps_append_all__works(void **state);
+extern void test__f_string_maps_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_maps_append_all__works(void **state);
 extern void test__f_string_maps_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_maps_append_all()
  */
-extern void test__f_string_maps_append_all__parameter_checking(void **state);
+extern void test__f_string_maps_append_all__works(void **state);
 
 #endif // _TEST__F_string_maps_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-mapss_append.c b/level_0/f_string/tests/unit/c/test-string-mapss_append.c
index 1cd4a8dce..e40b380cf 100644
--- a/level_0/f_string/tests/unit/c/test-string-mapss_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-mapss_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_mapss_append__parameter_checking(void **state) {
+
+  f_string_maps_t data = f_string_maps_t_initialize;
+
+  {
+    const f_status_t status = f_string_mapss_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_mapss_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_maps_t source = f_string_mapss_t_initialize;
+  f_string_mapss_t destination = f_string_mapss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_mapss_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_mapss_append__works(void **state) {
 
   const int length_inner = 2;
@@ -78,43 +115,6 @@ void test__f_string_mapss_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_mapss_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_maps_t source = f_string_mapss_t_initialize;
-  f_string_mapss_t destination = f_string_mapss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_mapss_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_mapss_append__parameter_checking(void **state) {
-
-  f_string_maps_t data = f_string_maps_t_initialize;
-
-  {
-    const f_status_t status = f_string_mapss_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-mapss_append.h b/level_0/f_string/tests/unit/c/test-string-mapss_append.h
index 0a9369f0f..9d8915214 100644
--- a/level_0/f_string/tests/unit/c/test-string-mapss_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-mapss_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_mapss_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_mapss_append()
  */
-extern void test__f_string_mapss_append__works(void **state);
+extern void test__f_string_mapss_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_mapss_append__works(void **state);
 extern void test__f_string_mapss_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_mapss_append()
  */
-extern void test__f_string_mapss_append__parameter_checking(void **state);
+extern void test__f_string_mapss_append__works(void **state);
 
 #endif // _TEST__F_string_mapss_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-mapss_append_all.c b/level_0/f_string/tests/unit/c/test-string-mapss_append_all.c
index 1ef308898..ad6ea3988 100644
--- a/level_0/f_string/tests/unit/c/test-string-mapss_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-mapss_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_mapss_append_all__parameter_checking(void **state) {
+
+  const f_string_mapss_t data = f_string_mapss_t_initialize;
+
+  {
+    const f_status_t status = f_string_mapss_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_mapss_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_mapss_t source = f_string_mapss_t_initialize;
+  f_string_mapss_t destination = f_string_mapss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_maps_t), (void **) &source.array, &source.used, &source.size, &f_string_mapss_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_mapss_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_mapss_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -103,43 +140,6 @@ void test__f_string_mapss_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_mapss_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_mapss_t source = f_string_mapss_t_initialize;
-  f_string_mapss_t destination = f_string_mapss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_maps_t), (void **) &source.array, &source.used, &source.size, &f_string_mapss_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_mapss_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_mapss_append_all__parameter_checking(void **state) {
-
-  const f_string_mapss_t data = f_string_mapss_t_initialize;
-
-  {
-    const f_status_t status = f_string_mapss_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-mapss_append_all.h b/level_0/f_string/tests/unit/c/test-string-mapss_append_all.h
index caa162984..b7aaba7c1 100644
--- a/level_0/f_string/tests/unit/c/test-string-mapss_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-mapss_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_mapss_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_mapss_append_all()
  */
-extern void test__f_string_mapss_append_all__works(void **state);
+extern void test__f_string_mapss_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_mapss_append_all__works(void **state);
 extern void test__f_string_mapss_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_mapss_append_all()
  */
-extern void test__f_string_mapss_append_all__parameter_checking(void **state);
+extern void test__f_string_mapss_append_all__works(void **state);
 
 #endif // _TEST__F_string_mapss_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-mash.c b/level_0/f_string/tests/unit/c/test-string-mash.c
index 6300ec5f6..28d798db3 100644
--- a/level_0/f_string/tests/unit/c/test-string-mash.c
+++ b/level_0/f_string/tests/unit/c/test-string-mash.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_mash__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_mash(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_mash__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -37,18 +49,6 @@ void test__f_string_mash__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_mash__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_mash(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-mash.h b/level_0/f_string/tests/unit/c/test-string-mash.h
index 8120d7b44..601ea7294 100644
--- a/level_0/f_string/tests/unit/c/test-string-mash.h
+++ b/level_0/f_string/tests/unit/c/test-string-mash.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_mash_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_mash()
  */
-extern void test__f_string_mash__works(void **state);
+extern void test__f_string_mash__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_mash()
  */
-extern void test__f_string_mash__parameter_checking(void **state);
+extern void test__f_string_mash__works(void **state);
 
 #endif // _TEST__F_string_mash_h
diff --git a/level_0/f_string/tests/unit/c/test-string-mash_nulless.c b/level_0/f_string/tests/unit/c/test-string-mash_nulless.c
index 7673a3d29..70edb23d7 100644
--- a/level_0/f_string/tests/unit/c/test-string-mash_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-mash_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_mash_nulless__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_mash_nulless__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -35,18 +47,6 @@ void test__f_string_mash_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_mash_nulless__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-mash_nulless.h b/level_0/f_string/tests/unit/c/test-string-mash_nulless.h
index ed9e38c52..4691d29bb 100644
--- a/level_0/f_string/tests/unit/c/test-string-mash_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-mash_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_mash_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_mash_nulless()
  */
-extern void test__f_string_mash_nulless__works(void **state);
+extern void test__f_string_mash_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_mash_nulless()
  */
-extern void test__f_string_mash_nulless__parameter_checking(void **state);
+extern void test__f_string_mash_nulless__works(void **state);
 
 #endif // _TEST__F_string_mash_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-mish.c b/level_0/f_string/tests/unit/c/test-string-mish.c
index f57f5803c..98a87f081 100644
--- a/level_0/f_string/tests/unit/c/test-string-mish.c
+++ b/level_0/f_string/tests/unit/c/test-string-mish.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_mish__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_mish(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_mish__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -37,18 +49,6 @@ void test__f_string_mish__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_mish__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_mish(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-mish.h b/level_0/f_string/tests/unit/c/test-string-mish.h
index d15bad74c..8c4a2806a 100644
--- a/level_0/f_string/tests/unit/c/test-string-mish.h
+++ b/level_0/f_string/tests/unit/c/test-string-mish.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_mish_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_mish()
  */
-extern void test__f_string_mish__works(void **state);
+extern void test__f_string_mish__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_mish()
  */
-extern void test__f_string_mish__parameter_checking(void **state);
+extern void test__f_string_mish__works(void **state);
 
 #endif // _TEST__F_string_mish_h
diff --git a/level_0/f_string/tests/unit/c/test-string-mish_nulless.c b/level_0/f_string/tests/unit/c/test-string-mish_nulless.c
index 98d421d3d..125c6c919 100644
--- a/level_0/f_string/tests/unit/c/test-string-mish_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-mish_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_mish_nulless__parameter_checking(void **state) {
+
+  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+  {
+    const f_status_t status = f_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_mish_nulless__works(void **state) {
 
   const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
@@ -35,18 +47,6 @@ void test__f_string_mish_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_mish_nulless__parameter_checking(void **state) {
-
-  const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
-  {
-    const f_status_t status = f_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-mish_nulless.h b/level_0/f_string/tests/unit/c/test-string-mish_nulless.h
index a9fc86347..1c6563065 100644
--- a/level_0/f_string/tests/unit/c/test-string-mish_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-mish_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_mish_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_mish_nulless()
  */
-extern void test__f_string_mish_nulless__works(void **state);
+extern void test__f_string_mish_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_mish_nulless()
  */
-extern void test__f_string_mish_nulless__parameter_checking(void **state);
+extern void test__f_string_mish_nulless__works(void **state);
 
 #endif // _TEST__F_string_mish_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend.c b/level_0/f_string/tests/unit/c/test-string-prepend.c
index 7542ff46c..4ba605d78 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend.c
+++ b/level_0/f_string/tests/unit/c/test-string-prepend.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_prepend__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_prepend(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_prepend__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_prepend__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_prepend__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_prepend(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend.h b/level_0/f_string/tests/unit/c/test-string-prepend.h
index 8617a305d..a75446590 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend.h
+++ b/level_0/f_string/tests/unit/c/test-string-prepend.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_prepend_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_prepend()
  */
-extern void test__f_string_prepend__works(void **state);
+extern void test__f_string_prepend__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_prepend()
  */
-extern void test__f_string_prepend__parameter_checking(void **state);
+extern void test__f_string_prepend__works(void **state);
 
 #endif // _TEST__F_string_prepend_h
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend_assure.c b/level_0/f_string/tests/unit/c/test-string-prepend_assure.c
index 39093997f..2699371cb 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend_assure.c
+++ b/level_0/f_string/tests/unit/c/test-string-prepend_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_prepend_assure__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_prepend_assure(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_prepend_assure__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -34,17 +45,6 @@ void test__f_string_prepend_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_prepend_assure__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_prepend_assure(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend_assure.h b/level_0/f_string/tests/unit/c/test-string-prepend_assure.h
index 1dd75823b..d2b342e12 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend_assure.h
+++ b/level_0/f_string/tests/unit/c/test-string-prepend_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_prepend_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_prepend_assure()
  */
-extern void test__f_string_prepend_assure__works(void **state);
+extern void test__f_string_prepend_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_prepend_assure()
  */
-extern void test__f_string_prepend_assure__parameter_checking(void **state);
+extern void test__f_string_prepend_assure__works(void **state);
 
 #endif // _TEST__F_string_prepend_assure_h
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.c b/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.c
index aac9376af..bc05e1bfb 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_prepend_assure_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_prepend_assure_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_prepend_assure_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -33,17 +44,6 @@ void test__f_string_prepend_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_prepend_assure_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_prepend_assure_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.h b/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.h
index ae967af74..b468ffadf 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-prepend_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_prepend_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_prepend_assure_nulless()
  */
-extern void test__f_string_prepend_assure_nulless__works(void **state);
+extern void test__f_string_prepend_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_prepend_assure_nulless()
  */
-extern void test__f_string_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_prepend_assure_nulless__works(void **state);
 
 #endif // _TEST__F_string_prepend_assure_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend_nulless.c b/level_0/f_string/tests/unit/c/test-string-prepend_nulless.c
index 64b337c51..135a0eb4e 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend_nulless.c
+++ b/level_0/f_string/tests/unit/c/test-string-prepend_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_prepend_nulless__parameter_checking(void **state) {
+
+  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_string_prepend_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_prepend_nulless__works(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
@@ -23,17 +34,6 @@ void test__f_string_prepend_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_string_prepend_nulless__parameter_checking(void **state) {
-
-  const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_string_prepend_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-prepend_nulless.h b/level_0/f_string/tests/unit/c/test-string-prepend_nulless.h
index 17fdcd0ca..f2f685f84 100644
--- a/level_0/f_string/tests/unit/c/test-string-prepend_nulless.h
+++ b/level_0/f_string/tests/unit/c/test-string-prepend_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_prepend_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_prepend_nulless()
  */
-extern void test__f_string_prepend_nulless__works(void **state);
+extern void test__f_string_prepend_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_prepend_nulless()
  */
-extern void test__f_string_prepend_nulless__parameter_checking(void **state);
+extern void test__f_string_prepend_nulless__works(void **state);
 
 #endif // _TEST__F_string_prepend_nulless_h
diff --git a/level_0/f_string/tests/unit/c/test-string-seek_line.c b/level_0/f_string/tests/unit/c/test-string-seek_line.c
index b48fb9239..448725a5d 100644
--- a/level_0/f_string/tests/unit/c/test-string-seek_line.c
+++ b/level_0/f_string/tests/unit/c/test-string-seek_line.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_seek_line__parameter_checking(void **state) {
+
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+  {
+    const f_status_t status = f_string_seek_line(source.string, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_seek_line__returns_data_not_stop(void **state) {
 
   const f_string_static_t source = macro_f_string_static_t_initialize_1("test\nafter", 0, 10);
@@ -50,17 +61,6 @@ void test__f_string_seek_line__works(void **state) {
   }
 }
 
-void test__f_string_seek_line__parameter_checking(void **state) {
-
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
-  {
-    const f_status_t status = f_string_seek_line(source.string, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-seek_line.h b/level_0/f_string/tests/unit/c/test-string-seek_line.h
index 71769afde..393eca18a 100644
--- a/level_0/f_string/tests/unit/c/test-string-seek_line.h
+++ b/level_0/f_string/tests/unit/c/test-string-seek_line.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_string_seek_line_h
 #define _TEST__F_string_seek_line_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_seek_line()
+ */
+extern void test__f_string_seek_line__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -31,11 +38,4 @@ extern void test__f_string_seek_line__returns_none_stop(void **state);
  */
 extern void test__f_string_seek_line__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_seek_line()
- */
-extern void test__f_string_seek_line__parameter_checking(void **state);
-
 #endif // _TEST__F_string_seek_line_h
diff --git a/level_0/f_string/tests/unit/c/test-string-seek_line_to.c b/level_0/f_string/tests/unit/c/test-string-seek_line_to.c
index 0384ab1be..e79ebfdf7 100644
--- a/level_0/f_string/tests/unit/c/test-string-seek_line_to.c
+++ b/level_0/f_string/tests/unit/c/test-string-seek_line_to.c
@@ -22,6 +22,18 @@ void test__f_string_seek_line_to__at_newline(void **state) {
   }
 }
 
+void test__f_string_seek_line_to__parameter_checking(void **state) {
+
+  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+  {
+    const f_status_t status = f_string_seek_line_to(source.string, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_seek_line_to__returns_data_not_stop(void **state) {
 
   const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
@@ -70,18 +82,6 @@ void test__f_string_seek_line_to__works(void **state) {
   }
 }
 
-void test__f_string_seek_line_to__parameter_checking(void **state) {
-
-  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
-  {
-    const f_status_t status = f_string_seek_line_to(source.string, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-seek_line_to.h b/level_0/f_string/tests/unit/c/test-string-seek_line_to.h
index 616433c02..e4fb259d5 100644
--- a/level_0/f_string/tests/unit/c/test-string-seek_line_to.h
+++ b/level_0/f_string/tests/unit/c/test-string-seek_line_to.h
@@ -17,6 +17,13 @@
  */
 extern void test__f_string_seek_line_to__at_newline(void **state);
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_seek_line_to()
+ */
+extern void test__f_string_seek_line_to__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -38,11 +45,4 @@ extern void test__f_string_seek_line_to__returns_none_stop(void **state);
  */
 extern void test__f_string_seek_line_to__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_seek_line_to()
- */
-extern void test__f_string_seek_line_to__parameter_checking(void **state);
-
 #endif // _TEST__F_string_seek_line_to_h
diff --git a/level_0/f_string/tests/unit/c/test-string-seek_to.c b/level_0/f_string/tests/unit/c/test-string-seek_to.c
index 95f465497..7122e6fce 100644
--- a/level_0/f_string/tests/unit/c/test-string-seek_to.c
+++ b/level_0/f_string/tests/unit/c/test-string-seek_to.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_string_seek_to__parameter_checking(void **state) {
+
+  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+  {
+    const f_status_t status = f_string_seek_to(source.string, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_seek_to__returns_data_not_stop(void **state) {
 
   const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
@@ -53,18 +65,6 @@ void test__f_string_seek_to__works(void **state) {
   }
 }
 
-void test__f_string_seek_to__parameter_checking(void **state) {
-
-  const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
-  const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
-  {
-    const f_status_t status = f_string_seek_to(source.string, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-seek_to.h b/level_0/f_string/tests/unit/c/test-string-seek_to.h
index ece924ab4..db8419061 100644
--- a/level_0/f_string/tests/unit/c/test-string-seek_to.h
+++ b/level_0/f_string/tests/unit/c/test-string-seek_to.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_string_seek_to_h
 #define _TEST__F_string_seek_to_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_seek_to()
+ */
+extern void test__f_string_seek_to__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -31,11 +38,4 @@ extern void test__f_string_seek_to__returns_none_stop(void **state);
  */
 extern void test__f_string_seek_to__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_seek_to()
- */
-extern void test__f_string_seek_to__parameter_checking(void **state);
-
 #endif // _TEST__F_string_seek_to_h
diff --git a/level_0/f_string/tests/unit/c/test-string-triples_append.c b/level_0/f_string/tests/unit/c/test-string-triples_append.c
index c0afa2cc5..fa25e5eeb 100644
--- a/level_0/f_string/tests/unit/c/test-string-triples_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-triples_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_string_triples_append__parameter_checking(void **state) {
+
+  const f_string_triple_t data = f_string_triple_t_initialize;
+
+  {
+    const f_status_t status = f_string_triples_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_string_triples_append__works(void **state) {
 
   const f_string_static_t test_a = macro_f_string_static_t_initialize_1("a", 0, 1);
@@ -34,17 +45,6 @@ void test__f_string_triples_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_triples_append__parameter_checking(void **state) {
-
-  const f_string_triple_t data = f_string_triple_t_initialize;
-
-  {
-    const f_status_t status = f_string_triples_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-triples_append.h b/level_0/f_string/tests/unit/c/test-string-triples_append.h
index af1bb6629..f3520f75c 100644
--- a/level_0/f_string/tests/unit/c/test-string-triples_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-triples_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_string_triples_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_triples_append()
  */
-extern void test__f_string_triples_append__works(void **state);
+extern void test__f_string_triples_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_triples_append()
  */
-extern void test__f_string_triples_append__parameter_checking(void **state);
+extern void test__f_string_triples_append__works(void **state);
 
 #endif // _TEST__F_string_triples_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-triples_append_all.c b/level_0/f_string/tests/unit/c/test-string-triples_append_all.c
index 279491ba6..67984cb40 100644
--- a/level_0/f_string/tests/unit/c/test-string-triples_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-triples_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_triples_append_all__parameter_checking(void **state) {
+
+  const f_string_triples_t data = f_string_triples_t_initialize;
+
+  {
+    const f_status_t status = f_string_triples_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_triples_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_triples_t source = f_string_triples_t_initialize;
+  f_string_triples_t destination = f_string_triples_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_triples_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_triples_append_all__works(void **state) {
 
   const int length_sources = 2;
@@ -54,43 +91,6 @@ void test__f_string_triples_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_triples_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_triples_t source = f_string_triples_t_initialize;
-  f_string_triples_t destination = f_string_triples_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_triples_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_triples_append_all__parameter_checking(void **state) {
-
-  const f_string_triples_t data = f_string_triples_t_initialize;
-
-  {
-    const f_status_t status = f_string_triples_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-triples_append_all.h b/level_0/f_string/tests/unit/c/test-string-triples_append_all.h
index ceb89508b..4780d9613 100644
--- a/level_0/f_string/tests/unit/c/test-string-triples_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-triples_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_triples_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_triples_append_all()
  */
-extern void test__f_string_triples_append_all__works(void **state);
+extern void test__f_string_triples_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_triples_append_all__works(void **state);
 extern void test__f_string_triples_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_triples_append_all()
  */
-extern void test__f_string_triples_append_all__parameter_checking(void **state);
+extern void test__f_string_triples_append_all__works(void **state);
 
 #endif // _TEST__F_string_triples_append_all_h
diff --git a/level_0/f_string/tests/unit/c/test-string-tripless_append.c b/level_0/f_string/tests/unit/c/test-string-tripless_append.c
index e455a0ac7..e21633c39 100644
--- a/level_0/f_string/tests/unit/c/test-string-tripless_append.c
+++ b/level_0/f_string/tests/unit/c/test-string-tripless_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_tripless_append__parameter_checking(void **state) {
+
+  f_string_triples_t data = f_string_triples_t_initialize;
+
+  {
+    const f_status_t status = f_string_tripless_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_tripless_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_triples_t source = f_string_tripless_t_initialize;
+  f_string_tripless_t destination = f_string_tripless_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_tripless_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_tripless_append__works(void **state) {
 
   const int length_sources = 2;
@@ -54,43 +91,6 @@ void test__f_string_tripless_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_tripless_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_triples_t source = f_string_tripless_t_initialize;
-  f_string_tripless_t destination = f_string_tripless_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_tripless_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_tripless_append__parameter_checking(void **state) {
-
-  f_string_triples_t data = f_string_triples_t_initialize;
-
-  {
-    const f_status_t status = f_string_tripless_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-tripless_append.h b/level_0/f_string/tests/unit/c/test-string-tripless_append.h
index 7efb56928..f7204b75d 100644
--- a/level_0/f_string/tests/unit/c/test-string-tripless_append.h
+++ b/level_0/f_string/tests/unit/c/test-string-tripless_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_tripless_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_tripless_append()
  */
-extern void test__f_string_tripless_append__works(void **state);
+extern void test__f_string_tripless_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_tripless_append__works(void **state);
 extern void test__f_string_tripless_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_tripless_append()
  */
-extern void test__f_string_tripless_append__parameter_checking(void **state);
+extern void test__f_string_tripless_append__works(void **state);
 
 #endif // _TEST__F_string_tripless_append_h
diff --git a/level_0/f_string/tests/unit/c/test-string-tripless_append_all.c b/level_0/f_string/tests/unit/c/test-string-tripless_append_all.c
index 0202f613b..a0fc2c67d 100644
--- a/level_0/f_string/tests/unit/c/test-string-tripless_append_all.c
+++ b/level_0/f_string/tests/unit/c/test-string-tripless_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_string_tripless_append_all__parameter_checking(void **state) {
+
+  const f_string_tripless_t data = f_string_tripless_t_initialize;
+
+  {
+    const f_status_t status = f_string_tripless_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_string_tripless_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_string_tripless_t source = f_string_tripless_t_initialize;
+  f_string_tripless_t destination = f_string_tripless_t_initialize;
+
+  {
+    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triples_t), (void **) &source.array, &source.used, &source.size, &f_string_tripless_delete_callback);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_string_tripless_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_string_tripless_append_all__works(void **state) {
 
   const int length_sources = 2;
@@ -80,43 +117,6 @@ void test__f_string_tripless_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_string_tripless_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_string_tripless_t source = f_string_tripless_t_initialize;
-  f_string_tripless_t destination = f_string_tripless_t_initialize;
-
-  {
-    const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triples_t), (void **) &source.array, &source.used, &source.size, &f_string_tripless_delete_callback);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_string_tripless_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_string_tripless_append_all__parameter_checking(void **state) {
-
-  const f_string_tripless_t data = f_string_tripless_t_initialize;
-
-  {
-    const f_status_t status = f_string_tripless_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_string/tests/unit/c/test-string-tripless_append_all.h b/level_0/f_string/tests/unit/c/test-string-tripless_append_all.h
index 597013135..c6cbf9866 100644
--- a/level_0/f_string/tests/unit/c/test-string-tripless_append_all.h
+++ b/level_0/f_string/tests/unit/c/test-string-tripless_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_string_tripless_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_string_tripless_append_all()
  */
-extern void test__f_string_tripless_append_all__works(void **state);
+extern void test__f_string_tripless_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_string_tripless_append_all__works(void **state);
 extern void test__f_string_tripless_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_string_tripless_append_all()
  */
-extern void test__f_string_tripless_append_all__parameter_checking(void **state);
+extern void test__f_string_tripless_append_all__works(void **state);
 
 #endif // _TEST__F_string_tripless_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append.c b/level_0/f_utf/tests/unit/c/test-utf-append.c
index a83720817..a12bf9bf9 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_append__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_append(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_append__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -24,17 +35,6 @@ void test__f_utf_append__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_append__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_append(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append.h b/level_0/f_utf/tests/unit/c/test-utf-append.h
index cf7d8dc21..254afd7f8 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_append()
  */
-extern void test__f_utf_append__works(void **state);
+extern void test__f_utf_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_append()
  */
-extern void test__f_utf_append__parameter_checking(void **state);
+extern void test__f_utf_append__works(void **state);
 
 #endif // _TEST__F_utf_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append_assure.c b/level_0/f_utf/tests/unit/c/test-utf-append_assure.c
index fe0ce1e96..84f6f4a30 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append_assure.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-append_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_append_assure__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_append_assure(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_append_assure__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -36,17 +47,6 @@ void test__f_utf_append_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_append_assure__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_append_assure(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append_assure.h b/level_0/f_utf/tests/unit/c/test-utf-append_assure.h
index 8819f152d..f49140696 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append_assure.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-append_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_append_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_append_assure()
  */
-extern void test__f_utf_append_assure__works(void **state);
+extern void test__f_utf_append_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_append_assure()
  */
-extern void test__f_utf_append_assure__parameter_checking(void **state);
+extern void test__f_utf_append_assure__works(void **state);
 
 #endif // _TEST__F_utf_append_assure_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.c
index 8971c0f16..e4ca32fc1 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_append_assure_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_append_assure_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_append_assure_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -37,17 +48,6 @@ void test__f_utf_append_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_append_assure_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_append_assure_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.h
index 06d3d8d54..328c766ea 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-append_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_append_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_append_assure_nulless()
  */
-extern void test__f_utf_append_assure_nulless__works(void **state);
+extern void test__f_utf_append_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_append_assure_nulless()
  */
-extern void test__f_utf_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_append_assure_nulless__works(void **state);
 
 #endif // _TEST__F_utf_append_assure_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-append_nulless.c
index de30383b6..f86a01028 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-append_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_append_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_append_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_append_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -25,17 +36,6 @@ void test__f_utf_append_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_append_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_append_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-append_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-append_nulless.h
index 245fa3546..8e2509da4 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-append_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-append_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_append_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_append_nulless()
  */
-extern void test__f_utf_append_nulless__works(void **state);
+extern void test__f_utf_append_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_append_nulless()
  */
-extern void test__f_utf_append_nulless__parameter_checking(void **state);
+extern void test__f_utf_append_nulless__works(void **state);
 
 #endif // _TEST__F_utf_append_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.c
index bea2752cd..3563bc349 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_append_assure(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_append_assure__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -36,17 +47,6 @@ void test__f_utf_string_dynamic_append_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_append_assure(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.h
index 811cffe93..ba3fe5ea9 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_append_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_append_assure()
  */
-extern void test__f_utf_string_dynamic_append_assure__works(void **state);
+extern void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_append_assure()
  */
-extern void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_append_assure__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_append_assure_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.c
index eeb44c044..bae840943 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_append_assure_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_append_assure_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -37,17 +48,6 @@ void test__f_utf_string_dynamic_append_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_append_assure_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.h
index 0ab23a14b..7f8fb3598 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_append_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_append_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_append_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_append_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_append_assure_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_append_assure_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.c
index 980717514..a7679cf8e 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_append_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_append_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -25,17 +36,6 @@ void test__f_utf_string_dynamic_append_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_append_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.h
index 1c502ad69..07f15f861 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_append_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_append_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_append_nulless()
  */
-extern void test__f_utf_string_dynamic_append_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_append_nulless()
  */
-extern void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_append_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_append_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.c
index 226ecbcfc..b602c28ee 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_mash__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_mash(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_mash__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -38,18 +50,6 @@ void test__f_utf_string_dynamic_mash__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_mash__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_mash(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.h
index ba9341218..8e648a323 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_mash_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_mash()
  */
-extern void test__f_utf_string_dynamic_mash__works(void **state);
+extern void test__f_utf_string_dynamic_mash__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_mash()
  */
-extern void test__f_utf_string_dynamic_mash__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mash__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_mash_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.c
index 2d7dd4d86..4194abe9f 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_mash_nulless(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_mash_nulless__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -39,18 +51,6 @@ void test__f_utf_string_dynamic_mash_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_mash_nulless(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.h
index f8eac83aa..ca167be2f 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mash_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_mash_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_mash_nulless()
  */
-extern void test__f_utf_string_dynamic_mash_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_mash_nulless()
  */
-extern void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mash_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_mash_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.c
index fd4adacef..8e59ed205 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_mish__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_mish(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_mish__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -38,18 +50,6 @@ void test__f_utf_string_dynamic_mish__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_mish__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_mish(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.h
index 2155c6483..59f370936 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_mish_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_mish()
  */
-extern void test__f_utf_string_dynamic_mish__works(void **state);
+extern void test__f_utf_string_dynamic_mish__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_mish()
  */
-extern void test__f_utf_string_dynamic_mish__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mish__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_mish_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.c
index 9bf652352..0a4b56305 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_mish_nulless(glue, source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_mish_nulless__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -39,18 +51,6 @@ void test__f_utf_string_dynamic_mish_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_mish_nulless(glue, source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.h
index 3be4e7327..947bb17bc 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_mish_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_mish_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_mish_nulless()
  */
-extern void test__f_utf_string_dynamic_mish_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_mish_nulless()
  */
-extern void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mish_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_mish_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.c
index 590087706..b8dc67f5f 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_append(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_append__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -26,18 +38,6 @@ void test__f_utf_string_dynamic_partial_append__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_append(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.h
index 6873b417f..28f4c308f 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_append()
  */
-extern void test__f_utf_string_dynamic_partial_append__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_append()
  */
-extern void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.c
index e1d10cbf2..73e2a8107 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_append_assure(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_append_assure__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -38,18 +50,6 @@ void test__f_utf_string_dynamic_partial_append_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_append_assure(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.h
index d33436298..9d376bedb 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_append_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_append_assure()
  */
-extern void test__f_utf_string_dynamic_partial_append_assure__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_append_assure()
  */
-extern void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_append_assure_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.c
index eaae1be25..794cbd9b5 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_append_assure_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -38,18 +50,6 @@ void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **stat
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_append_assure_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.h
index 9ce437e66..d63c13b06 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_append_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_append_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_append_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_append_assure_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.c
index a794a28b6..88dad1929 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_append_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_append_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -26,18 +38,6 @@ void test__f_utf_string_dynamic_partial_append_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_append_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.h
index 67c8f62de..1263aee6a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_append_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_append_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_append_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_append_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_append_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_append_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.c
index 14b76c35e..5da48816e 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_mash(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_mash__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -40,19 +53,6 @@ void test__f_utf_string_dynamic_partial_mash__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_mash(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.h
index 17c519d32..11d0a1b2b 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_mash_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_mash()
  */
-extern void test__f_utf_string_dynamic_partial_mash__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_mash()
  */
-extern void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mash__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_mash_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.c
index cb473788f..f186ce833 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -40,19 +53,6 @@ void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.h
index 450b65143..18aacb080 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mash_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_mash_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_mash_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_mash_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_mash_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.c
index f3fef0e25..30be7c367 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_mish(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_mish__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -40,19 +53,6 @@ void test__f_utf_string_dynamic_partial_mish__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_mish(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.h
index 09375f7c4..04b3b97ad 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish.h
@@ -11,16 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_mish_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_mish()
  */
-extern void test__f_utf_string_dynamic_partial_mish__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state);
+
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_mish()
  */
-extern void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mish__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_mish_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.c
index a6ecee984..f2bed0983 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.c
@@ -5,6 +5,19 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -40,19 +53,6 @@ void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.h
index d5fc7adec..82e6e50ed 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_mish_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_mish_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_mish_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_mish_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_mish_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.c
index 76100c126..30114170c 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_prepend(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_prepend__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -26,18 +38,6 @@ void test__f_utf_string_dynamic_partial_prepend__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_prepend(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.h
index 2de8bd994..d02fa6e2d 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_prepend_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_prepend()
  */
-extern void test__f_utf_string_dynamic_partial_prepend__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_prepend()
  */
-extern void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_prepend_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.c
index 4b1824621..f1649c848 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_prepend_assure(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -38,18 +50,6 @@ void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_prepend_assure(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.h
index 0bd72dee9..40837f7c9 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_prepend_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_prepend_assure()
  */
-extern void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_prepend_assure()
  */
-extern void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_prepend_assure_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.c
index 0d1dd0877..245c548df 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -38,18 +50,6 @@ void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **sta
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.h
index 597b4bb2c..ae637b0e1 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_prepend_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_prepend_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_prepend_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_prepend_assure_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.c
index 004c09be1..960b46232 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+  const f_range_t partial = f_range_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_partial_prepend_nulless(data, partial, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
@@ -26,18 +38,6 @@ void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-  const f_range_t partial = f_range_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_partial_prepend_nulless(data, partial, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.h
index 84cb7edc6..95ef1cdd2 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_partial_prepend_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_partial_prepend_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_partial_prepend_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_partial_prepend_nulless()
  */
-extern void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_partial_prepend_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.c
index ae21b4f9f..a0b17b936 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_prepend__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_prepend(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_prepend__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -24,17 +35,6 @@ void test__f_utf_string_dynamic_prepend__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_prepend__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_prepend(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.h
index 5177ef9a2..1dd7b3b90 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_prepend_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_prepend()
  */
-extern void test__f_utf_string_dynamic_prepend__works(void **state);
+extern void test__f_utf_string_dynamic_prepend__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_prepend()
  */
-extern void test__f_utf_string_dynamic_prepend__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_prepend_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.c
index 7d4b1d809..c5040edfc 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_prepend_assure(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_prepend_assure__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -36,17 +47,6 @@ void test__f_utf_string_dynamic_prepend_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_prepend_assure(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.h
index 040e96b25..c3ada918e 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_prepend_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_prepend_assure()
  */
-extern void test__f_utf_string_dynamic_prepend_assure__works(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_prepend_assure()
  */
-extern void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_prepend_assure_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.c
index cdbd627e8..cadc9fadd 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_prepend_assure_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -37,17 +48,6 @@ void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_prepend_assure_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.h
index 63eea9645..e4541ba57 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_prepend_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_prepend_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_prepend_assure_nulless()
  */
-extern void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_prepend_assure_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.c
index 706b76ee4..7ad1f6217 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamic_prepend_nulless(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_prepend_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -25,17 +36,6 @@ void test__f_utf_string_dynamic_prepend_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamic_prepend_nulless(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.h
index c970a2ba5..336f6823a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_prepend_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamic_prepend_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamic_prepend_nulless()
  */
-extern void test__f_utf_string_dynamic_prepend_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamic_prepend_nulless()
  */
-extern void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend_nulless__works(void **state);
 
 #endif // _TEST__F_utf_dynamic_prepend_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.c
index ca80d908b..daa85a172 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state) {
+
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_seek_line(source, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_seek_line__returns_data_not_stop(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0s\0\0\0t\0\0\0\n\0\0\0a\0\0\0f\0\0\0t\0\0\0e\0\0\0r", 0, 10);
@@ -66,17 +77,6 @@ void test__f_utf_string_dynamic_seek_line__works(void **state) {
   }
 }
 
-void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state) {
-
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_seek_line(source, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.h
index 37242b515..46a40f951 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_utf_dynamic_seek_line_h
 #define _TEST__F_utf_dynamic_seek_line_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_dynamic_seek_line()
+ */
+extern void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -38,11 +45,4 @@ extern void test__f_utf_string_dynamic_seek_line__returns_none_stop(void **state
  */
 extern void test__f_utf_string_dynamic_seek_line__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_dynamic_seek_line()
- */
-extern void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state);
-
 #endif // _TEST__F_utf_dynamic_seek_line_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.c
index 46d9a2635..5384cdbad 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.c
@@ -39,6 +39,18 @@ void test__f_utf_string_dynamic_seek_line_to__before_newline(void **state) {
   }
 }
 
+void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state) {
+
+  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_seek_line_to(source, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_seek_line_to__returns_data_not_stop(void **state) {
 
   const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
@@ -87,18 +99,6 @@ void test__f_utf_string_dynamic_seek_line_to__returns_none_stop(void **state) {
   }
 }
 
-void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state) {
-
-  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_seek_line_to(source, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.h
index 1da941448..27ff9eac1 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_line_to.h
@@ -24,6 +24,13 @@ extern void test__f_utf_string_dynamic_seek_line_to__after_newline(void **state)
  */
 extern void test__f_utf_string_dynamic_seek_line_to__before_newline(void **state);
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_dynamic_seek_line_to()
+ */
+extern void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -45,11 +52,4 @@ extern void test__f_utf_string_dynamic_seek_line_to__returns_none_eos(void **sta
  */
 extern void test__f_utf_string_dynamic_seek_line_to__returns_none_stop(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_dynamic_seek_line_to()
- */
-extern void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state);
-
 #endif // _TEST__F_utf_dynamic_seek_line_to_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.c b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.c
index a4c034880..1df7acee7 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.c
@@ -39,6 +39,18 @@ void test__f_utf_string_dynamic_seek_to__before_newline(void **state) {
   }
 }
 
+void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state) {
+
+  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+  {
+    const f_status_t status = f_utf_string_dynamic_seek_to(source, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamic_seek_to__returns_data_not_stop(void **state) {
 
   const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
@@ -118,18 +130,6 @@ void test__f_utf_string_dynamic_seek_to__works(void **state) {
   }
 }
 
-void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state) {
-
-  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
-  {
-    const f_status_t status = f_utf_string_dynamic_seek_to(source, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.h b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.h
index bd008b7f1..44f10114f 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamic_seek_to.h
@@ -24,6 +24,13 @@ extern void test__f_utf_string_dynamic_seek_to__after_newline(void **state);
  */
 extern void test__f_utf_string_dynamic_seek_to__before_newline(void **state);
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_dynamic_seek_to()
+ */
+extern void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -45,11 +52,4 @@ extern void test__f_utf_string_dynamic_seek_to__returns_none_eos(void **state);
  */
 extern void test__f_utf_string_dynamic_seek_to__returns_none_stop(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_dynamic_seek_to()
- */
-extern void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state);
-
 #endif // _TEST__F_utf_dynamic_seek_to_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.c b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.c
index f2b30375a..46950fda1 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamics_append__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamics_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamics_append__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -26,17 +37,6 @@ void test__f_utf_string_dynamics_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_dynamics_append__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamics_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.h b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.h
index 02e32a6ed..13e4bdd9f 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_dynamics_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamics_append()
  */
-extern void test__f_utf_string_dynamics_append__works(void **state);
+extern void test__f_utf_string_dynamics_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamics_append()
  */
-extern void test__f_utf_string_dynamics_append__parameter_checking(void **state);
+extern void test__f_utf_string_dynamics_append__works(void **state);
 
 #endif // _TEST__F_utf_dynamics_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.c
index d067777fa..9a454c006 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamics_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamics_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_dynamics_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -90,17 +101,6 @@ void test__f_utf_string_dynamics_append_all__returns_data_not(void **state) {
   free((void *) source.array);
 }
 
-void test__f_utf_string_dynamics_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamics_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.h
index 6e7e29f62..3b8879804 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamics_append_all.h
@@ -11,24 +11,24 @@
 #define _TEST__F_utf_dynamics_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamics_append_all()
  */
-extern void test__f_utf_string_dynamics_append_all__works(void **state);
+extern void test__f_utf_string_dynamics_append_all__parameter_checking(void **state);
 
 /**
- * Test that the function returns F_data_not when asked to copy an empty structure.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamics_append_all()
  */
-extern void test__f_utf_string_dynamics_append_all__returns_data_not(void **state);
+extern void test__f_utf_string_dynamics_append_all__works(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function returns F_data_not when asked to copy an empty structure.
  *
  * @see f_utf_string_dynamics_append_all()
  */
-extern void test__f_utf_string_dynamics_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_dynamics_append_all__returns_data_not(void **state);
 
 #endif // _TEST__F_utf_dynamics_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.c b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.c
index 9cfe57052..a41889742 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamicss_append__parameter_checking(void **state) {
+
+  f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamicss_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_dynamicss_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_dynamics_t source = f_utf_string_dynamicss_t_initialize;
+  f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamic_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_dynamicss_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_dynamicss_append__works(void **state) {
 
   const int length_inner = 2;
@@ -65,43 +102,6 @@ void test__f_utf_string_dynamicss_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_dynamicss_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_dynamics_t source = f_utf_string_dynamicss_t_initialize;
-  f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamic_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_dynamicss_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_dynamicss_append__parameter_checking(void **state) {
-
-  f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamicss_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.h b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.h
index 2c8e28c86..97ea5d255 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_dynamicss_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamicss_append()
  */
-extern void test__f_utf_string_dynamicss_append__works(void **state);
+extern void test__f_utf_string_dynamicss_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_dynamicss_append__works(void **state);
 extern void test__f_utf_string_dynamicss_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamicss_append()
  */
-extern void test__f_utf_string_dynamicss_append__parameter_checking(void **state);
+extern void test__f_utf_string_dynamicss_append__works(void **state);
 
 #endif // _TEST__F_utf_dynamicss_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.c
index 1e06942c8..c3bce2d05 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_dynamicss_t data = f_utf_string_dynamicss_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_dynamicss_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_dynamicss_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_dynamicss_t source = f_utf_string_dynamicss_t_initialize;
+  f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamics_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_dynamicss_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_dynamicss_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -91,43 +128,6 @@ void test__f_utf_string_dynamicss_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_dynamicss_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_dynamicss_t source = f_utf_string_dynamicss_t_initialize;
-  f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamics_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_dynamicss_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_dynamicss_t data = f_utf_string_dynamicss_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_dynamicss_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.h
index 6242f3ee7..438d58ee2 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-dynamicss_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_dynamicss_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_dynamicss_append_all()
  */
-extern void test__f_utf_string_dynamicss_append_all__works(void **state);
+extern void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_dynamicss_append_all__works(void **state);
 extern void test__f_utf_string_dynamicss_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_dynamicss_append_all()
  */
-extern void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_dynamicss_append_all__works(void **state);
 
 #endif // _TEST__F_utf_dynamicss_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c
index 21f5fbae3..008bae1aa 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_map_multis_append__parameter_checking(void **state) {
+
+  const f_utf_string_map_multi_t data = f_utf_string_map_multi_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_map_multis_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_map_multis_append__works(void **state) {
 
   const int length_values = 2;
@@ -85,17 +96,6 @@ void test__f_utf_string_map_multis_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_map_multis_append__parameter_checking(void **state) {
-
-  const f_utf_string_map_multi_t data = f_utf_string_map_multi_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_map_multis_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.h b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.h
index 9099a23b5..c931d7b77 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_map_multis_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_map_multis_append()
  */
-extern void test__f_utf_string_map_multis_append__works(void **state);
+extern void test__f_utf_string_map_multis_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_map_multis_append()
  */
-extern void test__f_utf_string_map_multis_append__parameter_checking(void **state);
+extern void test__f_utf_string_map_multis_append__works(void **state);
 
 #endif // _TEST__F_utf_map_multis_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c
index 5614a7206..c0d850bca 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_map_multis_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_map_multis_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_map_multis_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_map_multis_t source = f_utf_string_map_multis_t_initialize;
+  f_utf_string_map_multis_t destination = f_utf_string_map_multis_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_map_multis_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_map_multis_append_all__works(void **state) {
 
   const int length_values = 2;
@@ -84,43 +121,6 @@ void test__f_utf_string_map_multis_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_map_multis_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_map_multis_t source = f_utf_string_map_multis_t_initialize;
-  f_utf_string_map_multis_t destination = f_utf_string_map_multis_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_map_multis_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_map_multis_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_map_multis_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.h
index bdfadee08..1fed1ff17 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_map_multis_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_map_multis_append_all()
  */
-extern void test__f_utf_string_map_multis_append_all__works(void **state);
+extern void test__f_utf_string_map_multis_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_map_multis_append_all__works(void **state);
 extern void test__f_utf_string_map_multis_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_map_multis_append_all()
  */
-extern void test__f_utf_string_map_multis_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_map_multis_append_all__works(void **state);
 
 #endif // _TEST__F_utf_map_multis_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c
index f4b4dd0f0..87561a346 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_map_multiss_append__parameter_checking(void **state) {
+
+  f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_map_multiss_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_map_multiss_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_map_multis_t source = f_utf_string_map_multiss_t_initialize;
+  f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_map_multiss_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_map_multiss_append__works(void **state) {
 
   const int length_values = 2;
@@ -99,43 +136,6 @@ void test__f_utf_string_map_multiss_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_map_multiss_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_map_multis_t source = f_utf_string_map_multiss_t_initialize;
-  f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_map_multiss_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_map_multiss_append__parameter_checking(void **state) {
-
-  f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_map_multiss_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.h b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.h
index 2885f9d7b..57c38b8ff 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_map_multiss_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_map_multiss_append()
  */
-extern void test__f_utf_string_map_multiss_append__works(void **state);
+extern void test__f_utf_string_map_multiss_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_map_multiss_append__works(void **state);
 extern void test__f_utf_string_map_multiss_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_map_multiss_append()
  */
-extern void test__f_utf_string_map_multiss_append__parameter_checking(void **state);
+extern void test__f_utf_string_map_multiss_append__works(void **state);
 
 #endif // _TEST__F_utf_map_multiss_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c
index 144597f1c..bcb2193d0 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_map_multiss_t data = f_utf_string_map_multiss_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_map_multiss_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_map_multiss_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_map_multiss_t source = f_utf_string_map_multiss_t_initialize;
+  f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_map_multiss_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_map_multiss_append_all__works(void **state) {
 
   const int length_values = 2;
@@ -125,43 +162,6 @@ void test__f_utf_string_map_multiss_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_map_multiss_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_map_multiss_t source = f_utf_string_map_multiss_t_initialize;
-  f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_map_multiss_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_map_multiss_t data = f_utf_string_map_multiss_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_map_multiss_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.h
index 75fbd989e..2ecd046a2 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_map_multiss_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_map_multiss_append_all()
  */
-extern void test__f_utf_string_map_multiss_append_all__works(void **state);
+extern void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_map_multiss_append_all__works(void **state);
 extern void test__f_utf_string_map_multiss_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_map_multiss_append_all()
  */
-extern void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_map_multiss_append_all__works(void **state);
 
 #endif // _TEST__F_utf_map_multiss_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-maps_append.c b/level_0/f_utf/tests/unit/c/test-utf-maps_append.c
index 6bf5e960b..69f18b598 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-maps_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-maps_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_maps_append__parameter_checking(void **state) {
+
+  const f_utf_string_map_t data = f_utf_string_map_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_maps_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_maps_append__works(void **state) {
 
   f_utf_string_map_t source = f_utf_string_map_t_initialize;
@@ -47,17 +58,6 @@ void test__f_utf_string_maps_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_maps_append__parameter_checking(void **state) {
-
-  const f_utf_string_map_t data = f_utf_string_map_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_maps_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-maps_append.h b/level_0/f_utf/tests/unit/c/test-utf-maps_append.h
index f6470757e..20fc81618 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-maps_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-maps_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_maps_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_maps_append()
  */
-extern void test__f_utf_string_maps_append__works(void **state);
+extern void test__f_utf_string_maps_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_maps_append()
  */
-extern void test__f_utf_string_maps_append__parameter_checking(void **state);
+extern void test__f_utf_string_maps_append__works(void **state);
 
 #endif // _TEST__F_utf_maps_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c
index 624893b86..799b2ae6a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_maps_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_maps_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_maps_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_maps_t source = f_utf_string_maps_t_initialize;
+  f_utf_string_maps_t destination = f_utf_string_maps_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_maps_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_maps_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -69,43 +106,6 @@ void test__f_utf_string_maps_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_maps_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_maps_t source = f_utf_string_maps_t_initialize;
-  f_utf_string_maps_t destination = f_utf_string_maps_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_maps_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_maps_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_maps_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.h
index c373085fe..fe17dec14 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_maps_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_maps_append_all()
  */
-extern void test__f_utf_string_maps_append_all__works(void **state);
+extern void test__f_utf_string_maps_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_maps_append_all__works(void **state);
 extern void test__f_utf_string_maps_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_maps_append_all()
  */
-extern void test__f_utf_string_maps_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_maps_append_all__works(void **state);
 
 #endif // _TEST__F_utf_maps_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c b/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c
index be6aa4786..1c5087426 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_mapss_append__parameter_checking(void **state) {
+
+  f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_mapss_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_mapss_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_maps_t source = f_utf_string_mapss_t_initialize;
+  f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_mapss_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_mapss_append__works(void **state) {
 
   const int length_inner = 2;
@@ -78,43 +115,6 @@ void test__f_utf_string_mapss_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_mapss_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_maps_t source = f_utf_string_mapss_t_initialize;
-  f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_mapss_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_mapss_append__parameter_checking(void **state) {
-
-  f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_mapss_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mapss_append.h b/level_0/f_utf/tests/unit/c/test-utf-mapss_append.h
index d95640d71..c971a2de9 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mapss_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-mapss_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_mapss_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_mapss_append()
  */
-extern void test__f_utf_string_mapss_append__works(void **state);
+extern void test__f_utf_string_mapss_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_mapss_append__works(void **state);
 extern void test__f_utf_string_mapss_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_mapss_append()
  */
-extern void test__f_utf_string_mapss_append__parameter_checking(void **state);
+extern void test__f_utf_string_mapss_append__works(void **state);
 
 #endif // _TEST__F_utf_mapss_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c
index 4509cba30..e9011fd73 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_mapss_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_mapss_t data = f_utf_string_mapss_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_mapss_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_mapss_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_mapss_t source = f_utf_string_mapss_t_initialize;
+  f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_mapss_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_mapss_append_all__works(void **state) {
 
   const int length_inner = 2;
@@ -103,43 +140,6 @@ void test__f_utf_string_mapss_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_mapss_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_mapss_t source = f_utf_string_mapss_t_initialize;
-  f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_mapss_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_mapss_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_mapss_t data = f_utf_string_mapss_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_mapss_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.h
index 8d1468882..03c514631 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_mapss_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_mapss_append_all()
  */
-extern void test__f_utf_string_mapss_append_all__works(void **state);
+extern void test__f_utf_string_mapss_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_mapss_append_all__works(void **state);
 extern void test__f_utf_string_mapss_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_mapss_append_all()
  */
-extern void test__f_utf_string_mapss_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_mapss_append_all__works(void **state);
 
 #endif // _TEST__F_utf_mapss_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mash.c b/level_0/f_utf/tests/unit/c/test-utf-mash.c
index 893422ee7..51ed5b5cb 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mash.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mash.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_mash__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_mash(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_mash__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -38,18 +50,6 @@ void test__f_utf_mash__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_mash__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_mash(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mash.h b/level_0/f_utf/tests/unit/c/test-utf-mash.h
index a0765d020..9bef06f17 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mash.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-mash.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_mash_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_mash()
  */
-extern void test__f_utf_mash__works(void **state);
+extern void test__f_utf_mash__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_mash()
  */
-extern void test__f_utf_mash__parameter_checking(void **state);
+extern void test__f_utf_mash__works(void **state);
 
 #endif // _TEST__F_utf_mash_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.c
index f00c74c71..dcfc6d1db 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_mash_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_mash_nulless__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -39,18 +51,6 @@ void test__f_utf_mash_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_mash_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.h
index ec2205109..f751983c6 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-mash_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_mash_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_mash_nulless()
  */
-extern void test__f_utf_mash_nulless__works(void **state);
+extern void test__f_utf_mash_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_mash_nulless()
  */
-extern void test__f_utf_mash_nulless__parameter_checking(void **state);
+extern void test__f_utf_mash_nulless__works(void **state);
 
 #endif // _TEST__F_utf_mash_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mish.c b/level_0/f_utf/tests/unit/c/test-utf-mish.c
index ac68a5be8..304582f35 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mish.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mish.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_mish__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_mish(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_mish__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -38,18 +50,6 @@ void test__f_utf_mish__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_mish__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_mish(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mish.h b/level_0/f_utf/tests/unit/c/test-utf-mish.h
index 4df2112b0..6e44779a0 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mish.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-mish.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_mish_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_mish()
  */
-extern void test__f_utf_mish__works(void **state);
+extern void test__f_utf_mish__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_mish()
  */
-extern void test__f_utf_mish__parameter_checking(void **state);
+extern void test__f_utf_mish__works(void **state);
 
 #endif // _TEST__F_utf_mish_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.c
index 1c9bc4686..a519737ec 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.c
@@ -5,6 +5,18 @@
 extern "C" {
 #endif
 
+void test__f_utf_mish_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+  {
+    const f_status_t status = f_utf_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_mish_nulless__works(void **state) {
 
   const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
@@ -39,18 +51,6 @@ void test__f_utf_mish_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_mish_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
-  {
-    const f_status_t status = f_utf_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.h
index 7c8e8a5db..c2680d5f9 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-mish_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_mish_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_mish_nulless()
  */
-extern void test__f_utf_mish_nulless__works(void **state);
+extern void test__f_utf_mish_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_mish_nulless()
  */
-extern void test__f_utf_mish_nulless__parameter_checking(void **state);
+extern void test__f_utf_mish_nulless__works(void **state);
 
 #endif // _TEST__F_utf_mish_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend.c b/level_0/f_utf/tests/unit/c/test-utf-prepend.c
index 91b1998fe..cd5cfeca3 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_prepend__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_prepend(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_prepend__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -24,17 +35,6 @@ void test__f_utf_prepend__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_prepend__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_prepend(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend.h b/level_0/f_utf/tests/unit/c/test-utf-prepend.h
index b8d20424b..0e2c399e7 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_prepend_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_prepend()
  */
-extern void test__f_utf_prepend__works(void **state);
+extern void test__f_utf_prepend__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_prepend()
  */
-extern void test__f_utf_prepend__parameter_checking(void **state);
+extern void test__f_utf_prepend__works(void **state);
 
 #endif // _TEST__F_utf_prepend_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.c b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.c
index b75927c82..3f08ba491 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_prepend_assure__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_prepend_assure(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_prepend_assure__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -36,17 +47,6 @@ void test__f_utf_prepend_assure__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_prepend_assure__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_prepend_assure(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.h b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.h
index 12c2c6c37..3dcc2c0d0 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_prepend_assure_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_prepend_assure()
  */
-extern void test__f_utf_prepend_assure__works(void **state);
+extern void test__f_utf_prepend_assure__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_prepend_assure()
  */
-extern void test__f_utf_prepend_assure__parameter_checking(void **state);
+extern void test__f_utf_prepend_assure__works(void **state);
 
 #endif // _TEST__F_utf_prepend_assure_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.c
index ed0704280..5bb17f42b 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_prepend_assure_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_prepend_assure_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_prepend_assure_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -37,17 +48,6 @@ void test__f_utf_prepend_assure_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_prepend_assure_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_prepend_assure_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.h
index cec79f4c5..7f73a56e9 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend_assure_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_prepend_assure_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_prepend_assure_nulless()
  */
-extern void test__f_utf_prepend_assure_nulless__works(void **state);
+extern void test__f_utf_prepend_assure_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_prepend_assure_nulless()
  */
-extern void test__f_utf_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_prepend_assure_nulless__works(void **state);
 
 #endif // _TEST__F_utf_prepend_assure_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.c b/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.c
index c35bb412f..bdb81740a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_prepend_nulless__parameter_checking(void **state) {
+
+  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_prepend_nulless(data.string, data.used, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_prepend_nulless__works(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
@@ -25,17 +36,6 @@ void test__f_utf_prepend_nulless__works(void **state) {
   free((void *) destination.string);
 }
 
-void test__f_utf_prepend_nulless__parameter_checking(void **state) {
-
-  const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_prepend_nulless(data.string, data.used, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.h b/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.h
index 9349d32f2..c49bca402 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-prepend_nulless.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_prepend_nulless_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_prepend_nulless()
  */
-extern void test__f_utf_prepend_nulless__works(void **state);
+extern void test__f_utf_prepend_nulless__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_prepend_nulless()
  */
-extern void test__f_utf_prepend_nulless__parameter_checking(void **state);
+extern void test__f_utf_prepend_nulless__works(void **state);
 
 #endif // _TEST__F_utf_prepend_nulless_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-seek_line.c b/level_0/f_utf/tests/unit/c/test-utf-seek_line.c
index 75c667cbe..612e3114a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-seek_line.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-seek_line.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_seek_line__parameter_checking(void **state) {
+
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+  {
+    const f_status_t status = f_utf_string_seek_line(source.string, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_seek_line__returns_data_not_stop(void **state) {
 
   const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0s\0\0\0t\0\0\0\n\0\0\0a\0\0\0f\0\0\0t\0\0\0e\0\0\0r", 0, 10);
@@ -50,17 +61,6 @@ void test__f_utf_seek_line__works(void **state) {
   }
 }
 
-void test__f_utf_seek_line__parameter_checking(void **state) {
-
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
-  {
-    const f_status_t status = f_utf_string_seek_line(source.string, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-seek_line.h b/level_0/f_utf/tests/unit/c/test-utf-seek_line.h
index ae1cf4de4..31465b84d 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-seek_line.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-seek_line.h
@@ -10,6 +10,13 @@
 #ifndef _TEST__F_utf_seek_line_h
 #define _TEST__F_utf_seek_line_h
 
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_seek_line()
+ */
+extern void test__f_utf_seek_line__parameter_checking(void **state);
+
 /**
  * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
@@ -31,11 +38,4 @@ extern void test__f_utf_seek_line__returns_none_stop(void **state);
  */
 extern void test__f_utf_seek_line__works(void **state);
 
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_seek_line()
- */
-extern void test__f_utf_seek_line__parameter_checking(void **state);
-
 #endif // _TEST__F_utf_seek_line_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.c b/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.c
index 47c84c388..65f954ca1 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.c
@@ -39,6 +39,18 @@ void test__f_utf_seek_line_to__before_newline(void **state) {
   }
 }
 
+void test__f_utf_seek_line_to__parameter_checking(void **state) {
+
+  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+  {
+    const f_status_t status = f_utf_string_seek_line_to(source.string, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_seek_line_to__returns_data_not_stop(void **state) {
 
   const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
@@ -70,18 +82,6 @@ void test__f_utf_seek_line_to__returns_none_stop(void **state) {
   }
 }
 
-void test__f_utf_seek_line_to__parameter_checking(void **state) {
-
-  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
-  {
-    const f_status_t status = f_utf_string_seek_line_to(source.string, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.h b/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.h
index 8dc8d1026..58b085d47 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-seek_line_to.h
@@ -25,24 +25,24 @@ extern void test__f_utf_seek_line_to__after_newline(void **state);
 extern void test__f_utf_seek_line_to__before_newline(void **state);
 
 /**
- * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_seek_line_to()
  */
-extern void test__f_utf_seek_line_to__returns_data_not_stop(void **state);
+extern void test__f_utf_seek_line_to__parameter_checking(void **state);
 
 /**
- * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
+ * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
  * @see f_utf_string_seek_line_to()
  */
-extern void test__f_utf_seek_line_to__returns_none_stop(void **state);
+extern void test__f_utf_seek_line_to__returns_data_not_stop(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
  *
  * @see f_utf_string_seek_line_to()
  */
-extern void test__f_utf_seek_line_to__parameter_checking(void **state);
+extern void test__f_utf_seek_line_to__returns_none_stop(void **state);
 
 #endif // _TEST__F_utf_seek_line_to_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-seek_to.c b/level_0/f_utf/tests/unit/c/test-utf-seek_to.c
index b246a27a2..77c50f776 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-seek_to.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-seek_to.c
@@ -39,6 +39,18 @@ void test__f_utf_seek_to__before_newline(void **state) {
   }
 }
 
+void test__f_utf_seek_to__parameter_checking(void **state) {
+
+  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+  {
+    const f_status_t status = f_utf_string_seek_to(source.string, to.string[0], 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_seek_to__returns_data_not_stop(void **state) {
 
   const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
@@ -70,18 +82,6 @@ void test__f_utf_seek_to__returns_none_stop(void **state) {
   }
 }
 
-void test__f_utf_seek_to__parameter_checking(void **state) {
-
-  const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
-  const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
-  {
-    const f_status_t status = f_utf_string_seek_to(source.string, to.string[0], 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-seek_to.h b/level_0/f_utf/tests/unit/c/test-utf-seek_to.h
index 7184a812a..147299f90 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-seek_to.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-seek_to.h
@@ -25,24 +25,24 @@ extern void test__f_utf_seek_to__after_newline(void **state);
 extern void test__f_utf_seek_to__before_newline(void **state);
 
 /**
- * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_seek_to()
  */
-extern void test__f_utf_seek_to__returns_data_not_stop(void **state);
+extern void test__f_utf_seek_to__parameter_checking(void **state);
 
 /**
- * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
+ * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
  *
  * @see f_utf_string_seek_to()
  */
-extern void test__f_utf_seek_to__returns_none_stop(void **state);
+extern void test__f_utf_seek_to__returns_data_not_stop(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
  *
  * @see f_utf_string_seek_to()
  */
-extern void test__f_utf_seek_to__parameter_checking(void **state);
+extern void test__f_utf_seek_to__returns_none_stop(void **state);
 
 #endif // _TEST__F_utf_seek_to_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-triples_append.c b/level_0/f_utf/tests/unit/c/test-utf-triples_append.c
index 6df419944..b3e3d0122 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-triples_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-triples_append.c
@@ -5,6 +5,17 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_triples_append__parameter_checking(void **state) {
+
+  const f_utf_string_triple_t data = f_utf_string_triple_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_triples_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
 void test__f_utf_string_triples_append__works(void **state) {
 
   const f_utf_string_static_t test_a = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0a", 0, 1);
@@ -34,17 +45,6 @@ void test__f_utf_string_triples_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_triples_append__parameter_checking(void **state) {
-
-  const f_utf_string_triple_t data = f_utf_string_triple_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_triples_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-triples_append.h b/level_0/f_utf/tests/unit/c/test-utf-triples_append.h
index 0bd3465d8..ced4f9dfb 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-triples_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-triples_append.h
@@ -11,17 +11,17 @@
 #define _TEST__F_utf_triples_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_triples_append()
  */
-extern void test__f_utf_string_triples_append__works(void **state);
+extern void test__f_utf_string_triples_append__parameter_checking(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_triples_append()
  */
-extern void test__f_utf_string_triples_append__parameter_checking(void **state);
+extern void test__f_utf_string_triples_append__works(void **state);
 
 #endif // _TEST__F_utf_triples_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c
index f9ac70347..46267b35a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_triples_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_triples_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_triples_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_triples_t source = f_utf_string_triples_t_initialize;
+  f_utf_string_triples_t destination = f_utf_string_triples_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triple_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_triples_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_triples_append_all__works(void **state) {
 
   const int length_sources = 2;
@@ -54,43 +91,6 @@ void test__f_utf_string_triples_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_triples_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_triples_t source = f_utf_string_triples_t_initialize;
-  f_utf_string_triples_t destination = f_utf_string_triples_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triple_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_triples_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_triples_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_triples_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.h
index 5fe86785b..9a5675cda 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_triples_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_triples_append_all()
  */
-extern void test__f_utf_string_triples_append_all__works(void **state);
+extern void test__f_utf_string_triples_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_triples_append_all__works(void **state);
 extern void test__f_utf_string_triples_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_triples_append_all()
  */
-extern void test__f_utf_string_triples_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_triples_append_all__works(void **state);
 
 #endif // _TEST__F_utf_triples_append_all_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c b/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c
index 45be3894b..41e391a2c 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_tripless_append__parameter_checking(void **state) {
+
+  f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_tripless_append(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_tripless_append__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_triples_t source = f_utf_string_tripless_t_initialize;
+  f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_tripless_append(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_tripless_append__works(void **state) {
 
   const int length_sources = 2;
@@ -54,43 +91,6 @@ void test__f_utf_string_tripless_append__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_tripless_append__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_triples_t source = f_utf_string_tripless_t_initialize;
-  f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_tripless_append(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_tripless_append__parameter_checking(void **state) {
-
-  f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_tripless_append(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-tripless_append.h b/level_0/f_utf/tests/unit/c/test-utf-tripless_append.h
index ded84deea..eef0053b2 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-tripless_append.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-tripless_append.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_tripless_append_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_tripless_append()
  */
-extern void test__f_utf_string_tripless_append__works(void **state);
+extern void test__f_utf_string_tripless_append__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_tripless_append__works(void **state);
 extern void test__f_utf_string_tripless_append__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_tripless_append()
  */
-extern void test__f_utf_string_tripless_append__parameter_checking(void **state);
+extern void test__f_utf_string_tripless_append__works(void **state);
 
 #endif // _TEST__F_utf_tripless_append_h
diff --git a/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c
index a074ed5f3..6e7d83af8 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c
@@ -5,6 +5,43 @@
 extern "C" {
 #endif
 
+void test__f_utf_string_tripless_append_all__parameter_checking(void **state) {
+
+  const f_utf_string_tripless_t data = f_utf_string_tripless_t_initialize;
+
+  {
+    const f_status_t status = f_utf_string_tripless_append_all(data, 0);
+
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
+}
+
+void test__f_utf_string_tripless_append_all__returns_data_not(void **state) {
+
+  const int length = 5;
+  f_utf_string_tripless_t source = f_utf_string_tripless_t_initialize;
+  f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
+
+  {
+    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
+
+    assert_int_equal(status, F_okay);
+    assert_int_equal(source.used, 0);
+    assert_int_equal(source.size, length);
+  }
+
+  {
+    const f_status_t status = f_utf_string_tripless_append_all(source, &destination);
+
+    assert_int_equal(status, F_data_not);
+    assert_int_equal(destination.used, 0);
+    assert_int_equal(destination.size, 0);
+    assert_null(destination.array);
+  }
+
+  free((void *) source.array);
+}
+
 void test__f_utf_string_tripless_append_all__works(void **state) {
 
   const int length_sources = 2;
@@ -80,43 +117,6 @@ void test__f_utf_string_tripless_append_all__works(void **state) {
   free((void *) destination.array);
 }
 
-void test__f_utf_string_tripless_append_all__returns_data_not(void **state) {
-
-  const int length = 5;
-  f_utf_string_tripless_t source = f_utf_string_tripless_t_initialize;
-  f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
-
-  {
-    const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
-
-    assert_int_equal(status, F_okay);
-    assert_int_equal(source.used, 0);
-    assert_int_equal(source.size, length);
-  }
-
-  {
-    const f_status_t status = f_utf_string_tripless_append_all(source, &destination);
-
-    assert_int_equal(status, F_data_not);
-    assert_int_equal(destination.used, 0);
-    assert_int_equal(destination.size, 0);
-    assert_null(destination.array);
-  }
-
-  free((void *) source.array);
-}
-
-void test__f_utf_string_tripless_append_all__parameter_checking(void **state) {
-
-  const f_utf_string_tripless_t data = f_utf_string_tripless_t_initialize;
-
-  {
-    const f_status_t status = f_utf_string_tripless_append_all(data, 0);
-
-    assert_int_equal(status, F_status_set_error(F_parameter));
-  }
-}
-
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.h b/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.h
index 22d30de96..d68d2216a 100644
--- a/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.h
+++ b/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.h
@@ -11,11 +11,11 @@
 #define _TEST__F_utf_tripless_append_all_h
 
 /**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
  *
  * @see f_utf_string_tripless_append_all()
  */
-extern void test__f_utf_string_tripless_append_all__works(void **state);
+extern void test__f_utf_string_tripless_append_all__parameter_checking(void **state);
 
 /**
  * Test that the function returns F_data_not when asked to copy an empty structure.
@@ -25,10 +25,10 @@ extern void test__f_utf_string_tripless_append_all__works(void **state);
 extern void test__f_utf_string_tripless_append_all__returns_data_not(void **state);
 
 /**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
  *
  * @see f_utf_string_tripless_append_all()
  */
-extern void test__f_utf_string_tripless_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_tripless_append_all__works(void **state);
 
 #endif // _TEST__F_utf_tripless_append_all_h
-- 
2.47.3