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.

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 a2396804028b9314712de8eb9d846637f2c0dd88..f0dd4e86aee90981dd04e2e81878243da7362789 100644 (file)
--- 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 2ee97dcde27418c307e6a5e8dcecf18f710895ec..247fefbcac014f3dbd43142bbdb46e603b13d08d 100644 (file)
--- 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 ce2407d25fc77a863319a7da799102c692dc1944..b7f3c1b695a9cfbd634eda2ffcecd34922ac9bf9 100644 (file)
--- 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 02d75afb1643e1d31c4255023791a8d6593b84e0..3b94e5a0ba6ff1691cee198a6c77bc5e953e4946 100644 (file)
--- 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 41c2d0774e450b6068153f6b73e769f0dd0f24d6..6cd2b73b2d2d26f6725eae13de1c060a4cd1dd1d 100644 (file)
--- 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 8c72b30a85689a3ce320025a9ff92e14b6e197e7..0371eae6985af8d99f2c2ee069ca1cbbdfd248fc 100644 (file)
--- 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 479b9504cbc4066677e80110741cfb00c28369ea..ee4f8e3a03b55d2c8139a5b9ee06e4be08974731 100644 (file)
--- 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 7d1bf2076aef9abf36a00bb02c4170ffbc4e20e8..db684477d87a232430f11de4d10be368a21e4ada 100644 (file)
--- 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 0f0d5446a07419d89658137801177c5e114dfbeb..4f0aebfb161e13056a464a34572251a639040f79 100644 (file)
--- 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 a89a35e9c362c0b21bedd605798f86a2c94df71f..a2f8186d56eefe7a91fd2e219957db3b41e67aa7 100644 (file)
--- 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 511d85a38c5ebef69c7c2235a9574675ff0bb98d..8939501fd4b866a3f33bc053665e87265dc751fa 100644 (file)
--- 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 72d94577990d79bdadea0e86397038f0ac28679f..b3fa05d57253db88272f62845d6f0a888f1157eb 100644 (file)
--- 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 e94ac931a6cccd61906ad72dbb1b636a64127c7e..e5d6eefdaf2dfc77cf467120cab47d630d9aca85 100644 (file)
--- 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 83a7097d65fde0736c3a771489d7935d4e7629b9..b6ff3485c4b4124eb2a58027abaf1ace5b6ff6a3 100644 (file)
--- 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 48e24e0e8664a94eaba391c0aa2a59732c897e18..c5bc6becad452de93407701615e8815f1692c9e3 100644 (file)
--- 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 5942a5f22e0c866dca5072a8f9a149719af15af2..fd1b0068004a3a576649aed642e656dd44697b70 100644 (file)
--- 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 4a3ad7e662abd85043e1950df41f080ede118cad..ac20a5e637753d72339fcbe845d48e90203f6def 100644 (file)
--- 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 c92487d3d20e6fc555b3bdeaabb55d85fb9441ef..480cd39ef47b1cc284d406da4ffa7439c1def424 100644 (file)
--- 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 6aaaba3f595290f0f2e55b3858b7c9e7fc6798ca..aa7f15401c6da4cb1af8e47bab66596776032a53 100644 (file)
--- 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 47440974fbf33ce0b074ea42431b812cbb2b6716..5d7146f0e41f8c251c473f2b2c24d622b8c57f46 100644 (file)
--- 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 7df910b0ee7c029675a4551d7368028d36b8f606..2428175ae94a8ec02790f1c7aaea3992aa3f2173 100644 (file)
--- 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 ba3ebde3963ed3b31fdc8b9736e83e7916653dbb..d99b0154e1c44845194ecc2321328f55f2a56972 100644 (file)
--- 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 42ee63547aa145ea2a8ae795b28101a7e423536c..911e07553a9c344356d1a7f4ca039198bc0cf55e 100644 (file)
--- 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 f3745b074f384a80f8e21267ae931f6645b39fcf..edcec8a5daa137310479d16405a9e752ac5e8d73 100644 (file)
--- 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 2e3a44ae80f7df5b6d02ca8193ef0b65a3d12ac7..a29827fe1884ed492ec967c1c5ef1adcc61cfd34 100644 (file)
--- 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 8bb8cdc36e1d955af371ef2b63243b875b1038e0..538b8050f55ea586928b76f7c6dbc8305ca01b61 100644 (file)
--- 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 67a96f3c30ee376c6555b6c146c0df684f5dd60a..67f510a2b7780df2ce4a147581b35d53f0b761e8 100644 (file)
--- 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 e8e6bf44364909ed6e58f63c2bdd236e2c104e81..23e5eef062b44c3e16cb148104f214e8704988d5 100644 (file)
--- 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 b3d555af202ca7556d9acc4e9564b01e736d457c..2e9463b2084be9103dc000b8d96f3c78b371b5ee 100644 (file)
--- 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 c46708cee4664222936b90332737e272ae91d442..b2a76548848c99c5c3eb54bc44aeebf768cd6dda 100644 (file)
--- 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 01d864fb787094d7b17c4796163124221c41ef91..56d6434459f716069a9758c598025eae41fefece 100644 (file)
--- 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 ddd85fc7034138b4196ea2c2c44abec4dd39d8e6..0b90780a4bb7ee320d7f6e696db7160a1be784df 100644 (file)
--- 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 fb357b3c0401008068492625ae63992ef90f9235..3de508539b40f30042f87a5ed987506f41424e2c 100644 (file)
--- 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 0629f3d98a3c2463cf5862dfb8ec44fd2b397571..20a2649b98ab5ede218fb4deafc176b993a7a3b9 100644 (file)
--- 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 0e8428d4c0f704dc335ccdcfc987e66bd7f57757..953017a13f77a337bf701ea7132eb49179836181 100644 (file)
--- 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 838fd0508402b4cdc9e5a0f0798be3ff662862b2..25d1f9c2d9dfa8881a589e55398f2ad0a8967d5c 100644 (file)
--- 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 f83dfe0f6f5ac934db396b7adffeb0583f56a920..f8de2b726b091eba7d1d2e7fb9d331b17c27fb31 100644 (file)
--- 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 5e27957192d581ff56f4448edff9a6261f8fd4a3..5ce563fbf5ead002d062bcfb7997b6e0914cf7e4 100644 (file)
--- 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 9c1afe731b690ea86aafbf0556d3cd24409fcaa3..c68956613ec518105917733f9ea32788274f34cf 100644 (file)
--- 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 29b02ec19f2fd7df0d1ab9e2f3a065b2e1574e2d..915f6772713da58c041f18207035473cb3b71bd0 100644 (file)
--- 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 decba43da961e68831387eb32b4f813742e16ef2..5ac7118c15b3961140cf848d1ba190f0fd41eb0d 100644 (file)
--- 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 891ac07027907f4f5bd2a36c75e632422b1a8b94..6b0cb2dccc887795fdbfec6e488d41fb85dbed3b 100644 (file)
--- 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 fa9c6ef64c92b2d95c9ce912eea042d4d30594a5..33d15c3e5038d6d42915cd4b629586e421315506 100644 (file)
--- 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 032c3b2d1ef72d08ec3162b8f4a94ee3b36e58ca..f6dffe4ff37d7cc2ccc3977903350c0065f333af 100644 (file)
--- 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 ccdaed3466a7b030e16a389a7528460c216c98f0..d00e8850185334c6e51e202936de9beb0ac60dc0 100644 (file)
--- 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 9139e1da04e9e63b8b4f13bce7d9c0b8bebb4942..cf025bc89556d501a2d7b84300138ce6c6ad3cc7 100644 (file)
--- 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 ab61193838222c326307fc0e1bb6fb3c8f90eaa3..f13bee34fbc027c50042e18160b45c2186563de4 100644 (file)
--- 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 f857f4e9cde6e4a0bb5f0e9c9a0f7a7781d3c83e..c480fe4d57625d532b59b57ae2fe1e459ca9bec9 100644 (file)
--- 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 9564944b21e4ebc2fa838a3773ff288a6e8624ee..16a5fd6faec3df13da72ce10d125ee737be99768 100644 (file)
--- 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 a27fc2a650566aaf5f9646c362b017a7b82d2636..abb086398ab63b3ed9ef2d138eb1dfbbaf90a8b0 100644 (file)
--- 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 c98cd2440bd920fe9533cf6a56db9e8c87359ddf..766bd86563d92cae1f4742522a7f6c4943695f01 100644 (file)
--- 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 5014d376e8c3c58fe4b5d1eada833aacf2ccb2ba..2be89d3d9310efec3869b7d4a21573ed9c44752a 100644 (file)
--- 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 c85fa827627bc57224e9312235d833c6c727a452..9e6f29ce842e29cda2608232c5819f06818d8546 100644 (file)
--- 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 62d99d0b4e1b00a0f16db65777a3ce0c959a9094..65d2ebeef69905affa367900eb981c72022d7a94 100644 (file)
--- 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 3a2f600230b227982d8b81dd374b181e9b29df03..30a344b86d08865b161fbc4bc65758248d2daa09 100644 (file)
--- 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 f1f7d3a96cc0b811824c4c33d12baf3b3c596ed0..b6b5724c8951f194ba3729eee4bec58401730470 100644 (file)
--- 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 1ab687a9c398d0ea4339fc657f7a3f6be799e230..00c33508111d6d086aa20091fafe046254c7bb36 100644 (file)
--- 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 aaaf36a9297045cb7f3ad763d8afe737162ac8a0..a90c1cef55b58fa67917af312fd6c8932fe3afdd 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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).
  *
  * @see f_string_dynamic_seek_line()
@@ -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 6141525c4b0a97e6343d43ee31bd2fbf8a0a279f..cdd1f87d47b72af86256dc97cd433d7fbeedcbcd 100644 (file)
--- 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 a2358310676aa49c6ac427a46906955f222d16be..b98b03e231f036a748627478d23fc5b5d7655da6 100644 (file)
--- 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
@@ -18,6 +18,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).
  *
  * @see f_string_dynamic_seek_line_to()
@@ -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 b2e9d51991b70fd99705248a2b3a33f38d152de2..b0b2b88a1f0596b3298d6b7b0f513c20246a100d 100644 (file)
--- 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 042d64e6d94e55d3a70bbf9b50f0986083f2e406..c05be09ce31894c0b4a4b480cd8ba769855e9df5 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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).
  *
  * @see f_string_dynamic_seek_to()
@@ -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 3e5eac83946d76627a846b11883b6f12961413f1..abb05026c15324b9ae6df9e22018c011ba7d3914 100644 (file)
--- 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 35d05d576ca212a223a5118f75feda13e1503d8b..2ea815d4379e1a3026cfd54d8524d72e8350fb06 100644 (file)
--- 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 180b3191c0279405ab32eecfd2c43c6a9d95655b..2ff250cd2e2c259bd40838e23ece39a905f3069f 100644 (file)
--- 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 8e73f931283b8758ba574377119d0256958f77c8..073b9c6090400d7b030119ebd8a7ae061ad35b4e 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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.
  *
  * @see f_string_dynamic_strip_null_range()
@@ -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 9c564c41bacdd47065217cf66dc6aca5c0566b33..d57aa5a3de61d74caed9dd8db02c8d441466f0a3 100644 (file)
--- 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 e4d6f3fe6db42f5bc43639b80a9df444debe3955..9c559a8a9e2b709419e7c428bafd4aa65a79f172 100644 (file)
--- 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 ead76404c4a68aac8d24722015104abb0fb76226..e65479bba3d0cca3e6dc2b4a2a7eba2f73b442b8 100644 (file)
--- 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 22d0f5fce2fdfea398084e21819f6ac25155073f..d1157592d46122ab6062a425c3d9081d19439545 100644 (file)
--- 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 9e17da4ff4b6fa1b38d0dbbe33c2461c5aae6da0..d7d654bac560bf863cbe0a54c5be7ac7551e4701 100644 (file)
--- 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 f5a2bb44eda971c16596dc481857007fee9e4174..92af808f64e54f3584d4ea6c776e320397a20ef1 100644 (file)
--- 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 f42dd32430a0621558f7a44dbcc3a92ed2eaf0c5..7c08f244295e6652f00832494ab934f9ac272347 100644 (file)
--- 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 eca0be53f5afc542e354ff6a76460c03cab41541..1c26cb1afbfcd0a710986a0fb4bd0c283fa37f6e 100644 (file)
--- 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 54c43cb60e79da88dc65506bba58d47563c06ade..a71d623c9d1f75c091ac622628a4da6bfaf929ea 100644 (file)
--- 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 84441f3e9d831f3560027d0c1a129c9b5d0c954a..bfec4204ad6b3d290764b29df6c4cde747fd3781 100644 (file)
--- 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 fedc2fb79f67d2a35fb1df7cbaba6ef7eaf00026..4b6ab91f698ddd20b2677dece52cbd3bae4673c8 100644 (file)
--- 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 858a94fa4f01fadf4d00f07d88507413cfd24df4..9a6eca5ada2fb6d2e23b6fd35a1f70f6a812f2be 100644 (file)
--- 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 46a816a465330c312dd049abe5449c0f4bbecac4..6f2d7b66f3fdf0b4627995ec11b2cfa99798162a 100644 (file)
--- 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 5c7dbbcdbcaed28e82fdcc73d5eda4a92e144823..d1fad5f49e8263c626a3f6c147979429c4a827e8 100644 (file)
--- 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 aa081f7582aa0ff37cf44faf89cd99077f6e0484..6fad9518346fceed4cab4ea5cde99bb821095d69 100644 (file)
--- 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 da35a9e14dc1ee27eba7b4e6d79c7401057416a4..03c49a67413876890b3c870d4c3f898952aecdb7 100644 (file)
--- 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 19a42c52dcb9f63fb909bcb990eaf7fe0e16e2c8..02f2c6670decab652714feb900f247c0d064b3b7 100644 (file)
--- 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 0a04a3c64d42e262097fe885ebc70fde711dd07c..0dfed2e4ee45b43cf41437c9c40a467564d47d93 100644 (file)
--- 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 a272a451a0636ed4f27e4ec3676a6b522f79af07..1e3a86433b1e90928119fd4ef4d25bef749ab0dc 100644 (file)
--- 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 9975c9ea4103e1933de32aa46855346369cb52b7..f17de6739da2ab76e207f4bf8c36f231271c7066 100644 (file)
--- 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 1cd4a8dce7bbceb0658e71553a84e9cdd4ec0ee7..e40b380cf43b2ec8741d4c2aa9ebd7f0624e071c 100644 (file)
--- 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 0a9369f0f5040a6a4bff465ae542c245ded91e91..9d89152146e07a7119e8e5a062077a01b9eb7d6c 100644 (file)
--- 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 1ef30889891d4df3b07af22ca2b881630d18c639..ad6ea398865af63703130e947cf81de40012e203 100644 (file)
--- 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 caa162984daf4486759597e04c8eda3de6b3205e..b7aaba7c16fe7298e7d89477ec11362ca9f05639 100644 (file)
--- 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 6300ec5f677ee95b27797380a00a635c7019404c..28d798db37590b715504a5f0fce68968277d9634 100644 (file)
--- 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 8120d7b445fdaeaf17948aa2da6668d14b2563c7..601ea729445f759dc2e5807e9f61da8731d304a6 100644 (file)
--- 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 7673a3d29072fc470f1bdff10cac37343fdbe872..70edb23d782121bbf8a9233901e0e6b3b338e918 100644 (file)
--- 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 ed9e38c52c4dcd70f9e6167c2eb9190ab918758e..4691d29bbabe146908b96ea858a748364ad59da4 100644 (file)
--- 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 f57f5803cd9d87d61393d12dd1c2471801bb1ae1..98a87f081fc3d79b31b965fc1f0c6b6cebff1175 100644 (file)
--- 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 d15bad74ce5a68dc658e269e7dcc510004fa2bca..8c4a2806a0f81fe5ffa7abf75f4d0647a9423706 100644 (file)
--- 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 98d421d3d40e2ae627c4e6e8b4a84a92c01bd5e0..125c6c919cd42d18aae8d105873fcb46eb31016e 100644 (file)
--- 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 a9fc86347d02b5b750315d47fe2d81b16418814b..1c6563065166bef35e9ebe3133b31647e6bc560b 100644 (file)
--- 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 7542ff46c8fff06640ad75b9407f340bdb4aab85..4ba605d782fe88cca4819348ba2a617ecb75e6af 100644 (file)
--- 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 8617a305db8ba3db8eb7c6321ecab49cc197b36b..a75446590db66040e96c9cfa992c61cf125cae16 100644 (file)
--- 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 39093997f855e599b59985d020407e26a8ed00cb..2699371cb42310c6134cb971c4c4c27b13f2830d 100644 (file)
--- 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 1dd75823b9ec37112cc93cebe63b688f59d4d2ca..d2b342e121892c38a87f4ed5732fa40478e59bf6 100644 (file)
--- 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 aac9376af09d70733a3fb352cdefb93566cb7cb0..bc05e1bfb7d0bd9eb189b894108cc298ad81b832 100644 (file)
--- 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 ae967af745508052b37e0fae44afb843646d90ca..b468ffadfcdf08ccdb0f3f39eefce79b256fdc82 100644 (file)
--- 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 64b337c513802cd7268d67fa0570a0024742fcd8..135a0eb4ef1d7c9a3e0ce868e6618c20c6d2d7be 100644 (file)
--- 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 17fdcd0cae456345ee4ac4ec64b9d4fafab64cf4..f2f685f84ff997a947b310d67b6f8010d1fd295e 100644 (file)
--- 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 b48fb92390c89719c08c33471143f2ce8a8b893e..448725a5d7b70c5b081ae5dd124efd4f2ccb6a77 100644 (file)
--- 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 71769afde995a4b6d5aaee1fa5c47086f7b49d2c..393eca18a7477e322864030d3516b8880d7069bf 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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).
  *
  * @see f_string_seek_line()
@@ -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 0384ab1be9f1972d1fa7bb94b1be241864cbd9c4..e79ebfdf7319c69a88c86f5250bda201e75da1fd 100644 (file)
--- 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 616433c0214270359048384afb3bc134d8dfbfa5..e4fb259d57776674a366e5323072d33ad3491456 100644 (file)
--- 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
@@ -18,6 +18,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).
  *
  * @see f_string_seek_line_to()
@@ -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 95f465497d7e317cc6a158f62b1ed18908cc2531..7122e6fce968b87f6843827ba3ebd848044bd933 100644 (file)
--- 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 ece924ab418260804c9f23936521e20edbb6e9b7..db8419061cfff0ac6af558b8f6800ebc3ed0b4c9 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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).
  *
  * @see f_string_seek_to()
@@ -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 c0afa2cc5f28d89c6f02ce44eca09ae63a66dca5..fa25e5eebc666a2184daa5416a186c9c26c0bd2d 100644 (file)
--- 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 af1bb66291329270f5002ba29dd5c18d17472b0b..f3520f75c43aa7f89fc0bb3f54bb73a55aceb6ee 100644 (file)
--- 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 279491ba66b38765d34d83d9b864b5cf40c27483..67984cb4069091bf108cfdd67e52ec8f237de092 100644 (file)
--- 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 ceb89508b37515e37ddfd88a34bac9bf54750585..4780d9613b6a843c07f5df4944d27dd95a7f4676 100644 (file)
--- 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 e455a0ac7f2513d59638415c60e3796a42fc3009..e21633c3964b386e2877c9d9da6cfbc2b3d3e0ce 100644 (file)
--- 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 7efb569283ad4b88777a80c1872d575f6a7074ee..f7204b75dff46930a6564ce16b68e59dabeec30d 100644 (file)
--- 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 0202f613be4045ae628c8b174021299b50daa027..a0fc2c67d9288e414c5d87cc206a77a8b0cfb9d2 100644 (file)
--- 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 59701313579def3da4ffb201b15837bdf802beab..c6cbf9866976cfd5680fac1e49a32729470bd0dc 100644 (file)
--- 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 a837208172c9da567e5d76a4334cbeb5a19c383d..a12bf9bf9a4cd01057628a6e22ea4f9a53847b45 100644 (file)
--- 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 cf7d8dc219b8240fc91c8c9456a555368643301f..254afd7f839318c8881fa9fc2f0bb2a7e81d6da4 100644 (file)
--- 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 fe0ce1e96c67352d3109f3acfddcdae00a7ad179..84f6f4a30cf42d6c11f905c622332b5a302c1d94 100644 (file)
--- 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 8819f152df8c45e27d22b6abc0e5ca47254ea6ca..f491406960079b7e91e7f80804b68391f6e25563 100644 (file)
--- 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 8971c0f162ef8cfd1f18585e63a12b8f4152fa80..e4ca32fc1bfc22a6fa924f5f9446225cfe92de16 100644 (file)
--- 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 06d3d8d54ed0cfc03da96e626e8a1d7e70817891..328c766eab09714eb77e4d7070e2da234781b4ca 100644 (file)
--- 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 de30383b6066a34eb6e99bca201feb7c5e2f2468..f86a01028a1b7b329f28ec2452cc933a2ebf6815 100644 (file)
--- 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 245fa3546c4f8c382fa82fee08cc65c08ba87981..8e2509da45531b40e4c4ec28156c59b2b7329eae 100644 (file)
--- 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 bea2752cd11c06498a35ed85a97be7972f9214c3..3563bc34946983bafcef737111f64e89580befc9 100644 (file)
--- 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 811cffe935537c473f491b645fa60a258b48172c..ba3fe5ea9a3f9ff5c3ae15bc36d1948595f13489 100644 (file)
--- 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 eeb44c04478667b6297b609af238a1664e8f1ab0..bae84094306f95e298ed3f2ac8af152638f3f591 100644 (file)
--- 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 0ab23a14bf32b5c297c7c49f007afb820cb0ce67..7f8fb3598d61ec618282c4cb4f28dca4e170e042 100644 (file)
--- 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 9807175145edb38d2f2198210d4a54a1a8db3693..a7679cf8e50947b4471cf2be09e10764f6f00126 100644 (file)
--- 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 1c502ad69925d1603092da9f4f4cb38f67502281..07f15f8617699eea29ccff978b2ba1850f93b006 100644 (file)
--- 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 226ecbcfc514049fdc5cfd5ca2f6a873b22de7cc..b602c28ee91548b12f9ef70778cb9c71c0ae4a6e 100644 (file)
--- 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 ba934121870f6196983639100b9befe72a4385c1..8e648a323a68d02dcfe0adda6fce37904eae5cdf 100644 (file)
--- 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 2d7dd4d864e8d871d6bea4b737c77a0e8a840f38..4194abe9f653096fc510a8d04724ce8837899bd8 100644 (file)
--- 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 f8eac83aaa16b0451f9a9460d3d02c15878d457f..ca167be2f7c5f406341ffd8d7e4dca2ecf236270 100644 (file)
--- 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 fd4adacef837e1b9c7c12a5144b5f2ff397d3b8e..8e59ed20584f7d8444dd8f1cc6655d6fda012622 100644 (file)
--- 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 2155c6483c169e4b36715bf24318b18db65c11a5..59f3709362fe42448aebf641773b82a2d1800d12 100644 (file)
--- 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 9bf652352e32fb39c20342378409775736959f4a..0a4b563058f8a85f0861647fddb1bc883f22e4a4 100644 (file)
--- 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 3be4e7327302df5fca34bb4f73d7f15f44d36f6a..947bb17bc7e85b2e42ca85e5aa8f9ed16346ad12 100644 (file)
--- 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 590087706ba7c0daf1f45378c67463776928dd10..b8dc67f5f4f3686fbad5ccfce324fd98b36d2c63 100644 (file)
--- 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 6873b417fea96a79e913a8a48ebbe2f95e7a5b6e..28f4c308fe7d9bc443314e84042b169883cb1d7e 100644 (file)
--- 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 e1d10cbf23a6685f1f50ae40e183ead1e1251656..73e2a8107c9896382a3dcea6a5269aaa70754314 100644 (file)
--- 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 d334362983b9c906018fa8b81cf7a4b1a44af222..9d376bedb1078e524211d5c72d587f368e8e698f 100644 (file)
--- 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 eaae1be25668bc7041124fa605cab8ca59535e3a..794cbd9b5299ddffb1ef1c88eb4451f2ac99930b 100644 (file)
--- 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 9ce437e66854b3da189962e4407013402c148ddc..d63c13b06ae998524ec0ad0214d36b9803d9ab44 100644 (file)
--- 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 a794a28b6470e21c988ff2b6b3fd1dd5846f2bef..88dad192988c41579a73537e4bdec2d1c8878499 100644 (file)
--- 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 67c8f62dec76fa7c46564da2c275fef63fdbc237..1263aee6a615edccf1c4df6d77d62048450777c4 100644 (file)
--- 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 14b76c35ef5ccdedd150a58fddaa09b400eb1f15..5da48816ebdc24da2d227f1af7294276e2130429 100644 (file)
--- 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 17c519d32649f54a3ef3d89bee5b1fd78003abf2..11d0a1b2be20a0ba8063f6dbbb8e2374a817bd3a 100644 (file)
--- 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 cb473788f4c7ad0ef382b05ce92af4fe0cb8d204..f186ce833fe6a099bbf9f93de240bd5d7df3e9a8 100644 (file)
--- 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 450b65143abcf8918f0f31c992a90570d6c85978..18aacb08037db3174e72f052697e40786dfe3d0f 100644 (file)
--- 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 f3fef0e254da48ee939d7ccfa58c8e280d8d4fc8..30be7c367661d6472cbb273e053ede46888a2dcc 100644 (file)
--- 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 09375f7c403cefad73cb558125254e73c6df9660..04b3b97ad29fee43a5a65606c41e25429bd01d91 100644 (file)
--- 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 a6ecee9843a274fa7535fc28a9c7fb0cc5cd090a..f2bed09836465ea5594e5c1e263ea634eea6bb4f 100644 (file)
--- 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 d5fc7adec804d7e5f8eec5a5b40bbf6f120dc4e4..82e6e50ed9946d55ba02c756eae75096e360315a 100644 (file)
--- 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 76100c126a9af2120b07834ee6f4fa17aae9ca1c..30114170c0bbb7e9d8bec09e7c9ed15340ff6e86 100644 (file)
--- 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 2de8bd99454eb53fd62221f9907a54ba7b6f4f9f..d02fa6e2dfcd4321419b0c8bd2db330bd445092c 100644 (file)
--- 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 4b1824621db58ebb7755942753385803f24a3b30..f1649c84805b961a97f134360d40c2104d3ca720 100644 (file)
--- 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 0bd72dee9534771b46d8f5d3c33d506cdc0b39ba..40837f7c96aab01c66f4442fd837ee31dac83c46 100644 (file)
--- 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 0d1dd0877cf41071dc84b66172997ffc4c6a3d8a..245c548dfc4b00bc4ca2f2cfab24c3104ba79aee 100644 (file)
--- 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 597b4bb2cf68692d0b810656186e6be196398325..ae637b0e181a06fa401369d92f141be1d8380cf4 100644 (file)
--- 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 004c09be152b84f85f0f90e15025233cdb1f5963..960b462326fddae1e37ce974aa0350e783a4e77c 100644 (file)
--- 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 84cb7edc6fdf12e8dc98c3fd0d235cbff3e97ba2..95ef1cdd23fc7b03b464fd033d08e5f6a0566e04 100644 (file)
--- 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 ae21b4f9f89238224f4596c71baa32246ab950dc..a0b17b936d207454d2cc7f11e7cbdd35a4cbfca9 100644 (file)
--- 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 5177ef9a2e626e110979302b95975ceba19ab4c8..1dd7b3b908b43dfc3a5a030af423bec8bae74fcb 100644 (file)
--- 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 7d4b1d809a5c1f68a20e313040495c636472ec60..c5040edfc14037b44090983d3ea2e083863f92e1 100644 (file)
--- 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 040e96b25e3a3de3482b95e54ac5c00ffd8ae403..c3ada918ef9d9ded21f8e16ffa3aac93a5f44fd0 100644 (file)
--- 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 cdbd627e833ea31acdda2d6ca484aad439e957a6..cadc9faddce151a0e12ed3d834ca44c47d4ac0a7 100644 (file)
--- 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 63eea964520c0214d9d0eb580e1ad78e4d7f30d5..e4541ba5760eaf8a5cfe83070c00f7c02e34420f 100644 (file)
--- 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 706b76ee4aade42f01d1e3b83c0fd19bbe417ca9..7ad1f6217443c91312c9427a53f5c3ad8449b7c0 100644 (file)
--- 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 c970a2ba54e54a4d0b54c4ccc9da1d8f15e80fd8..336f6823ab2b8e22799c8661c58ffc7d832e83d8 100644 (file)
--- 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 ca80d908bd8bfc07b18e1d887b88df8d96537e2d..daa85a172baf5c1288e634eb5df1ee59e4e1df92 100644 (file)
--- 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 37242b515c17f2e46f15314a6160a1c921642446..46a40f951042647a706c26176d51c0ed22104c42 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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).
  *
  * @see f_utf_string_dynamic_seek_line()
@@ -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 46d9a263500b85a726347059c1a4af15670070d6..5384cdbad38c799b64e02f67a697a055b0bf1eec 100644 (file)
--- 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 1da9414487bc797de625877c59f801d69ece0753..27ff9eac185d45310d7a3b8f5cac63740e2374d5 100644 (file)
--- 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
@@ -25,6 +25,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).
  *
  * @see f_utf_string_dynamic_seek_line_to()
@@ -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 a4c0348805a69a8eb94531b2f89721358c863b90..1df7acee74b6c375862d1456bc104e4a3bfacc13 100644 (file)
--- 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 bd008b7f160192665a6ea19820977f86c8a932a8..44f10114f58855aab3cd91694b157a7cd53f216c 100644 (file)
--- 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
@@ -25,6 +25,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).
  *
  * @see f_utf_string_dynamic_seek_to()
@@ -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 f2b30375a9595e71c9a77c65917a9dcc4409f308..46950fda144288157411af469ae0aeb8bab73b46 100644 (file)
--- 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 02e32a6edf34cfcb152fa9c15ad3da490b376183..13e4bdd9f83958b9596a153781abc304837f00e2 100644 (file)
--- 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 d067777faef7a16918ce909e5b579e942f425aa4..9a454c00667378282c2478f066f4e34ff2aff1e7 100644 (file)
--- 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 6e7e29f62be3aace8b1de6a0ef7fd97865fc92e0..3b88798048bf8be922d73806530347e803be3411 100644 (file)
--- 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 9cfe57052ef723303d92b32d4da0d283751bbd30..a41889742b845f88052504d9f9f7f2426e6e9037 100644 (file)
--- 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 2c8e28c867cda29a43da0c077aea293a3b10e20e..97ea5d2554c1e431f9c0d6d419850b2f44154d29 100644 (file)
--- 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 1e06942c8d8a705c3542993ffac2ebafb2485f50..c3bce2d0596dd06a7b1b77cf08d39ebdb2456a1b 100644 (file)
--- 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 6242f3ee77b64f0fda4bdaa7c5c9a4ef37a1e207..438d58ee201ae563da6d975c1f0cc09d436216ef 100644 (file)
--- 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 21f5fbae3775737ac2296c1fdec5955ff893fa64..008bae1aa17a5bca3ebc4ca0a113ed2d1e0ce52c 100644 (file)
--- 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 9099a23b580cf64d17fa6f99881a3b92db1d5cfd..c931d7b774b0334652f0b8d08fba82b0f5be8a30 100644 (file)
--- 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 5614a7206ec51944f90ca8547474236e2bf258e5..c0d850bca588336b615acde916b4b1a2cb953854 100644 (file)
--- 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 bdfadee083511af32244263068e8daf7ab361db5..1fed1ff17f337c924443c9e6f28a00b90deec721 100644 (file)
--- 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 f4b4dd0f063338cd555e2ec4b463c8b867b3f10e..87561a346cdde9e755cf23df5ce3fae90e2ad35e 100644 (file)
--- 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 2885f9d7b43302b6ae2635057fdbb458717e8fbb..57c38b8ff40d3643ee9e341e948f93674508905e 100644 (file)
--- 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 144597f1c0ee0765a1ee9ba8e2908ad7f36d7e84..bcb2193d0fd02d1985936b8df977c2a420a67fbc 100644 (file)
--- 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 75fbd989e889c55e616ef78cab0352e864c854d9..2ecd046a2705527ff47e00f59565aed71e7232f2 100644 (file)
--- 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 6bf5e960bf38ef7b9662ac703ae274cb0f0e1784..69f18b59859ecf33173f521644fa40c647b7ff73 100644 (file)
--- 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 f6470757ecb227abb2909de06cb9d10847c8d04f..20fc81618aa16e7f6b9bf354d035d7c827517af9 100644 (file)
--- 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 624893b86a0c14479d0b2ceb660f5eb7e3720604..799b2ae6ab5c89e3f73400970ffeaca0ff20660b 100644 (file)
--- 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 c373085fe4678f84d1a321dc9b7269f84e024337..fe17dec1460f37967da6f479d31aece5311111fb 100644 (file)
--- 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 be6aa4786f2344323296872a594caf7011303460..1c50874268c5beca2dc1ed680a3a4774ccaa7f44 100644 (file)
--- 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 d95640d71913a9443f2aee4a19142791505fa39c..c971a2de97ad05885d4e8f5a80bb77d06750d0b0 100644 (file)
--- 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 4509cba3097bed3ed9a3e2e4878809724276e3cd..e9011fd736d1e82f60ae86f0298200f63ee9adeb 100644 (file)
--- 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 8d1468882eb460fd8f3455ca5810b5fa0f506b90..03c5146314c1c4256fd7395ddefa58d4bdd2fe8e 100644 (file)
--- 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 893422ee773d50ff948ff913d90c0db30ca6e893..51ed5b5cbb6a455122927b510b47a630f1ede26b 100644 (file)
--- 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 a0765d02074025c6bc5b9f7258ccd12c4599fbf5..9bef06f17c3255120fa361a4de109aa57c34b633 100644 (file)
--- 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 f00c74c71823742002c8b6866ad21bfe40bdce8e..dcfc6d1db7d4184d684b7c8afa4f43ba730d21a7 100644 (file)
--- 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 ec220510915e743b3a0f464a62026bf429bbc674..f751983c61699028debee46def15f46d9e72de61 100644 (file)
--- 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 ac68a5be83ffb99847488cc3f350c8c0cc5ef7f4..304582f35e42a9f7f3563294e5802bc862e629da 100644 (file)
--- 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 4df2112b05518f2b516c98797d4df279bd4c5b6d..6e44779a052736bf71f3d1d128a42050e4d93e1b 100644 (file)
--- 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 1c9bc4686571796142a0ed8d4c64cee395a048db..a519737ec7066b1c235b72c65092e2752ba38f8d 100644 (file)
--- 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 7c8e8a5dbb5d4a57b66aa067c68c952ea9867c4c..c2680d5f9f2902b3fde5c5441f945edf74f4fa87 100644 (file)
--- 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 91b1998fe87da2da4a338d2c6cebf59035f2d2bd..cd5cfeca3163ec1141cb94f0e2f4cb8961df8447 100644 (file)
--- 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 b8d20424b858e833e9cceb8a814ef1e15f7d2257..0e2c399e71d4657e9fc49084bddc3f44a36c3e4a 100644 (file)
--- 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 b75927c8270cc6e295bd7262f1a0ec710155d7ef..3f08ba49125ae98d18dba83c977050cbb4254a29 100644 (file)
--- 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 12c2c6c37347c690c55757426810a554a2fce4a8..3dcc2c0d048d3fc85a3ec53668841145b6bc551b 100644 (file)
--- 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 ed0704280c26d4e599ff19abcb4fc4a8f3df40ca..5bb17f42bc4e1b631d5297078aa3c9672aebec68 100644 (file)
--- 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 cec79f4c557d922a4a27a5becaa2968525254fd0..7f73a56e9e5aca6e9e8f875c1dd0679668b99dd0 100644 (file)
--- 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 c35bb412fe5e03fd4dd37a4292d19d46ba6c96c6..bdb81740acc6d68d7d56d308f12c6f3f16fff24e 100644 (file)
--- 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 9349d32f25c4f152171e9bcf884bf4ea19e27b73..c49bca40256592d8351ecb8ffa445dcac3560ca4 100644 (file)
--- 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 75c667cbe134b60696f3cc9eb8429f5918940d2a..612e3114acbbcf920466868fd00750e1d05de7c7 100644 (file)
--- 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 ae1cf4de45e4e322307b45fcf5457f7356eb36f8..31465b84d75240f63b166a008a0f640275ff9398 100644 (file)
--- 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
@@ -11,6 +11,13 @@
 #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).
  *
  * @see f_utf_string_seek_line()
@@ -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 47c84c3882917098713539030b3acc010d116397..65f954ca122d9e019693fc648f86de4c20591801 100644 (file)
--- 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 8dc8d1026bcad10fd9fc3e22ac82cd837d8b70a0..58b085d47c9ec426afccce141add10c6da377a6f 100644 (file)
--- 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 b246a27a2028c60202a85faa4c8d836c0188fe48..77c50f776a94e844827bad5d0a82be09873bfd45 100644 (file)
--- 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 7184a812adc4c91c54f0d7443c43e7b166d0049e..147299f905f9933b8e423835b600f7140a7dccb6 100644 (file)
--- 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 6df419944944924ac817aad56ed13ef94da5f8eb..b3e3d012285d3cb1a18f5e3571358bdf3f339a24 100644 (file)
--- 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 0bd3465d8529819f49621b08a0200f5e8b32476a..ced4f9dfb8a9b1e1d7135c63c0e2b9b685a6afb1 100644 (file)
--- 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 f9ac703472c7720ad95b2ec95944d3de978aa74b..46267b35a801fc8cddc3a21227e0b94425c65125 100644 (file)
--- 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 5fe86785bbf7b2e81138d9903ede6a8f74ac0dcc..9a5675cda02174bb32e14e43549a0068487c7bb5 100644 (file)
--- 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 45be3894b671dbfe0d88f3080171bfa2c64cacff..41e391a2cdff403a704e246a22e8929d57851b5b 100644 (file)
--- 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 ded84deea79695c0b194c7a54469b75b1e2ad237..eef0053b2add7e51a674c2d36b2a6c437505be13 100644 (file)
--- 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 a074ed5f3e220c7749556c4953e8e2f2c95f77a5..6e7d83af8ed39e1b18ca5bdf9fc7375086174d92 100644 (file)
--- 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 22d30de9649ca96b030df7130e0065d8df664ae7..d68d2216a7459dd272b91db39d2108200b71dbb5 100644 (file)
--- 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