Cleanup: Remove the parameter checking macros around the function definitions in...

The tests do not really matter when it comes to file size.
Simplify the test code by not using these macros.

These macros are still used to perform the call.
They just do not need to be around the function definitions.

diff --git a/level_0/f_account/tests/unit/c/test-account-by_id.c b/level_0/f_account/tests/unit/c/test-account-by_id.c
index 384ef8287ab078c1756eb5e373f0afaa13e9bc1d..317ba1125da4796a5988d6f6727d3e333886f913 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-by_id.c
+++ b/level_0/f_account/tests/unit/c/test-account-by_id.c
@@ -66,16 +66,14 @@ void test__f_account_by_id__not_found(void **state) {
   macro_f_account_t_delete_simple(account);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_account_by_id__parameter_checking(void **state) {
+void test__f_account_by_id__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_account_by_id(0, 0);
+  {
+    const f_status_t status = f_account_by_id(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_account_by_id__works(void **state) {
 

diff --git a/level_0/f_account/tests/unit/c/test-account-by_id.h b/level_0/f_account/tests/unit/c/test-account-by_id.h
index 7910a76b738fd9f1eda3cc61b89f6ead5fa30d05..1ba72ed7158073f69c07bc571536c27b6acea316 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-by_id.h
+++ b/level_0/f_account/tests/unit/c/test-account-by_id.h
@@ -29,9 +29,7 @@ extern void test__f_account_by_id__not_found(void **state);
  *
  * @see f_account_by_id()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_account_by_id__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_account_by_id__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_account/tests/unit/c/test-account-by_name.c b/level_0/f_account/tests/unit/c/test-account-by_name.c
index fb59b4d52fbb0791aeb9ebfe17231a448c382e07..b302eb8409709b9b5b9b676d7c28c22f39af5777 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-by_name.c
+++ b/level_0/f_account/tests/unit/c/test-account-by_name.c
@@ -74,18 +74,16 @@ void test__f_account_by_name__not_found(void **state) {
   macro_f_account_t_delete_simple(account);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_account_by_name__parameter_checking(void **state) {
+void test__f_account_by_name__parameter_checking(void **state) {
 
-    const f_string_static_t name = f_string_static_t_initialize;
+  const f_string_static_t name = f_string_static_t_initialize;
 
-    {
-      const f_status_t status = f_account_by_name(name, 0);
+  {
+    const f_status_t status = f_account_by_name(name, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_account_by_name__works(void **state) {
 

diff --git a/level_0/f_account/tests/unit/c/test-account-by_name.h b/level_0/f_account/tests/unit/c/test-account-by_name.h
index 22129af22e6d961b837b2d71eeaddf0bd76c79c4..70c3d3193767953c0891d58a078b4f44177ee619 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-by_name.h
+++ b/level_0/f_account/tests/unit/c/test-account-by_name.h
@@ -29,9 +29,7 @@ extern void test__f_account_by_name__not_found(void **state);
  *
  * @see f_account_by_name()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_account_by_name__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_account_by_name__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_account/tests/unit/c/test-account-group_id_by_name.c b/level_0/f_account/tests/unit/c/test-account-group_id_by_name.c
index abe7e5f8a0e558d69d13bde246a5b6a075842a25..1700f455b7efbd1206ecbb5eb1f51e9fc022d817 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-group_id_by_name.c
+++ b/level_0/f_account/tests/unit/c/test-account-group_id_by_name.c
@@ -70,18 +70,16 @@ void test__f_account_group_id_by_name__not_found(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_account_group_id_by_name__parameter_checking(void **state) {
+void test__f_account_group_id_by_name__parameter_checking(void **state) {
 
-    const f_string_static_t name = f_string_static_t_initialize;
+  const f_string_static_t name = f_string_static_t_initialize;
 
-    {
-      const f_status_t status = f_account_group_id_by_name(name, 0);
+  {
+    const f_status_t status = f_account_group_id_by_name(name, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_account_group_id_by_name__works(void **state) {
 

diff --git a/level_0/f_account/tests/unit/c/test-account-group_id_by_name.h b/level_0/f_account/tests/unit/c/test-account-group_id_by_name.h
index 7f3ea750e23a1e3638c721ef84dad9a94e05e820..7f147c8dd2559c35d63908917e7481af1c9bee6c 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-group_id_by_name.h
+++ b/level_0/f_account/tests/unit/c/test-account-group_id_by_name.h
@@ -29,9 +29,7 @@ extern void test__f_account_group_id_by_name__not_found(void **state);
  *
  * @see f_account_group_id_by_name()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_account_group_id_by_name__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_account_group_id_by_name__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_account/tests/unit/c/test-account-group_name_by_id.c b/level_0/f_account/tests/unit/c/test-account-group_name_by_id.c
index 72b31bad2c5db39daf8b396be8a1752b1c8c542c..30093137113568be89874d37f68e26925a8e26e2 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-group_name_by_id.c
+++ b/level_0/f_account/tests/unit/c/test-account-group_name_by_id.c
@@ -66,16 +66,14 @@ void test__f_account_group_name_by_id__not_found(void **state) {
   f_string_dynamic_resize(0, &name);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_account_group_name_by_id__parameter_checking(void **state) {
+void test__f_account_group_name_by_id__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_account_group_name_by_id(0, 0);
+  {
+    const f_status_t status = f_account_group_name_by_id(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_account_group_name_by_id__works(void **state) {
 

diff --git a/level_0/f_account/tests/unit/c/test-account-group_name_by_id.h b/level_0/f_account/tests/unit/c/test-account-group_name_by_id.h
index 785c39b532b13c4fb3547006bdcab0d6efd8ee6a..7bb7f272768c04715d6108eb50c35ca4a5fa3a12 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-group_name_by_id.h
+++ b/level_0/f_account/tests/unit/c/test-account-group_name_by_id.h
@@ -29,9 +29,7 @@ extern void test__f_account_group_name_by_id__not_found(void **state);
  *
  * @see f_account_group_name_by_id()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_account_group_name_by_id__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_account_group_name_by_id__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_account/tests/unit/c/test-account-id_by_name.c b/level_0/f_account/tests/unit/c/test-account-id_by_name.c
index ebac5ea3195777ff553433c2b8bb4352793e2c4b..2d710322ce65518f0b32abe62a7d1b4aa0b626ee 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-id_by_name.c
+++ b/level_0/f_account/tests/unit/c/test-account-id_by_name.c
@@ -70,18 +70,16 @@ void test__f_account_id_by_name__not_found(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_account_id_by_name__parameter_checking(void **state) {
+void test__f_account_id_by_name__parameter_checking(void **state) {
 
-    const f_string_static_t name = f_string_static_t_initialize;
+  const f_string_static_t name = f_string_static_t_initialize;
 
-    {
-      const f_status_t status = f_account_id_by_name(name, 0);
+  {
+    const f_status_t status = f_account_id_by_name(name, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_account_id_by_name__works(void **state) {
 

diff --git a/level_0/f_account/tests/unit/c/test-account-id_by_name.h b/level_0/f_account/tests/unit/c/test-account-id_by_name.h
index 1aa619994c3cfe55e97b89282ae8a09919a94a01..f5a7cfa756874d8d45d5981f70ebaf4d70a79233 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-id_by_name.h
+++ b/level_0/f_account/tests/unit/c/test-account-id_by_name.h
@@ -29,9 +29,7 @@ extern void test__f_account_id_by_name__not_found(void **state);
  *
  * @see f_account_id_by_name()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_account_id_by_name__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_account_id_by_name__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_account/tests/unit/c/test-account-name_by_id.c b/level_0/f_account/tests/unit/c/test-account-name_by_id.c
index 16589176b76cd3ed58e47c52b9dbc8bf0819a80c..e8bf6d9a589fff023fc95e39beb0fe659e3f05ec 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-name_by_id.c
+++ b/level_0/f_account/tests/unit/c/test-account-name_by_id.c
@@ -66,16 +66,14 @@ void test__f_account_name_by_id__not_found(void **state) {
   f_string_dynamic_resize(0, &name);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_account_name_by_id__parameter_checking(void **state) {
+void test__f_account_name_by_id__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_account_name_by_id(0, 0);
+  {
+    const f_status_t status = f_account_name_by_id(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_account_name_by_id__works(void **state) {
 

diff --git a/level_0/f_account/tests/unit/c/test-account-name_by_id.h b/level_0/f_account/tests/unit/c/test-account-name_by_id.h
index 6920bb4028922feac899d2ea0973416627c05913..f69a8cb9e7bc5f6592960f95e29f22099c9df8b3 100644 (file)
--- a/level_0/f_account/tests/unit/c/test-account-name_by_id.h
+++ b/level_0/f_account/tests/unit/c/test-account-name_by_id.h
@@ -29,9 +29,7 @@ extern void test__f_account_name_by_id__not_found(void **state);
  *
  * @see f_account_name_by_id()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_account_name_by_id__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_account_name_by_id__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c b/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c
index 1642165f7b75875ed28e73c054c169c04ce3e865..317292bdd70f94d50721d90646878d4f48ae1047 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-ambient_get.c
@@ -22,18 +22,16 @@ void test__f_capability_ambient_get__fails(void **state) {
   #endif // !defined(_di_libcap_) && !defined(_libcap_legacy_only_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_ambient_get__parameter_checking(void **state) {
+void test__f_capability_ambient_get__parameter_checking(void **state) {
 
-    const f_capability_value_t value = f_capability_value_t_initialize;
+  const f_capability_value_t value = f_capability_value_t_initialize;
 
-    {
-      const f_status_t status = f_capability_ambient_get(value, 0);
+  {
+    const f_status_t status = f_capability_ambient_get(value, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_ambient_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-ambient_get.h b/level_0/f_capability/tests/unit/c/test-capability-ambient_get.h
index 4e8a39bb68de7a8511390598279340537c80dbbe..5fc5cc379cd9d9267116404a64389a99e26bd896 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-ambient_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-ambient_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_ambient_get__fails(void **state);
  *
  * @see f_capability_ambient_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_ambient_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_ambient_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-clear.c b/level_0/f_capability/tests/unit/c/test-capability-clear.c
index 7a42e82cc7ed939c81cde6a4bbc4865ffb92b531..da2255be5ea6db5ed71048da721404fb4d5bafc7 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-clear.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-clear.c
@@ -36,16 +36,14 @@ void test__f_capability_clear__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_clear__parameter_checking(void **state) {
+void test__f_capability_clear__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_clear(0);
+  {
+    const f_status_t status = f_capability_clear(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_clear__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-clear.h b/level_0/f_capability/tests/unit/c/test-capability-clear.h
index 392ac7e6933d985eb0ce4f88e64aaba491ea340e..70a99aa34dbee6edf330701cff8d42103d86b877 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-clear.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-clear.h
@@ -22,9 +22,7 @@ extern void test__f_capability_clear__fails(void **state);
  *
  * @see f_capability_clear()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_clear__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_clear__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c b/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c
index 8eba172da0aa54aa70a93b0d97f24fc196c661d3..e361f372298c316f3ddeef0afef8316ae4ce5248 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-clear_flag.c
@@ -8,7 +8,7 @@ extern "C" {
 #ifndef _di_level_0_parameter_checking_
   void test__f_capability_clear_flag__parameter_checking(void **state) {
 
-  const f_capability_flag_t flag = f_capability_flag_t_initialize;
+    const f_capability_flag_t flag = f_capability_flag_t_initialize;
 
     {
       const f_status_t status = f_capability_clear_flag(flag, 0);

diff --git a/level_0/f_capability/tests/unit/c/test-capability-clear_flag.h b/level_0/f_capability/tests/unit/c/test-capability-clear_flag.h
index 388e3e30c409b3f4670cd87107468fa686388bd7..e5663565760824a3395abf9fc1922861ef1ae3ea 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-clear_flag.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-clear_flag.h
@@ -22,9 +22,7 @@ extern void test__f_capability_clear_flag__fails(void **state);
  *
  * @see f_capability_clear_flag()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_clear_flag__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_clear_flag__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy.c b/level_0/f_capability/tests/unit/c/test-capability-copy.c
index 74d3433742ca54b6da173dbbcf2ff671b70866ed..9481a6204b9e382a1b02545bbda4c802da81e5bd 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy.c
@@ -23,18 +23,16 @@ void test__f_capability_copy__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_copy__parameter_checking(void **state) {
+void test__f_capability_copy__parameter_checking(void **state) {
 
-    const f_capability_t capability = f_capability_t_initialize;
+  const f_capability_t capability = f_capability_t_initialize;
 
-    {
-      const f_status_t status = f_capability_copy(capability, 0);
+  {
+    const f_status_t status = f_capability_copy(capability, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_copy__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy.h b/level_0/f_capability/tests/unit/c/test-capability-copy.h
index 6815e0084e2b50038074f4e36b56308504b9e29b..937ecc4ad7bccf903cf4376fecb4ae2ccf2a04a2 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy.h
@@ -29,8 +29,6 @@ extern void test__f_capability_copy__works(void **state);
  *
  * @see f_capability_copy()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_copy__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_copy__parameter_checking(void **state);
 
 #endif // _TEST__F_capability__copy_h

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy_external.c b/level_0/f_capability/tests/unit/c/test-capability-copy_external.c
index 4241bd1096c16e49aaef2caf88069f4e6f0d54c3..0052c310f1f4fa14caaa3762bd93b13ed7e63e51 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy_external.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy_external.c
@@ -38,18 +38,16 @@ void test__f_capability_copy_external__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_copy_external__parameter_checking(void **state) {
+void test__f_capability_copy_external__parameter_checking(void **state) {
 
-    f_capability_t capability = f_capability_t_initialize;
+  f_capability_t capability = f_capability_t_initialize;
 
-    {
-      const f_status_t status = f_capability_copy_external(capability, 0, 0, 0);
+  {
+    const f_status_t status = f_capability_copy_external(capability, 0, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_copy_external__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy_external.h b/level_0/f_capability/tests/unit/c/test-capability-copy_external.h
index 3d0c9a8e62121dfca015cf8a04f488d2122f9b80..819c445b211bb7222271728121f6160b0a06f0d7 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy_external.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy_external.h
@@ -22,9 +22,7 @@ extern void test__f_capability_copy_external__fails(void **state);
  *
  * @see f_capability_copy_external()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_copy_external__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_copy_external__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c b/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c
index bc07f4f12be596b4839e50f1dd213d67e9371245..f8d93c2abd99e400b23e4c9071a0bec927f274c3 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy_internal.c
@@ -36,26 +36,24 @@ void test__f_capability_copy_internal__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_copy_internal__parameter_checking(void **state) {
+void test__f_capability_copy_internal__parameter_checking(void **state) {
 
-    f_capability_t capability = f_capability_t_initialize;
-    int stub = 0;
-    void *external = (void *) &stub;
+  f_capability_t capability = f_capability_t_initialize;
+  int stub = 0;
+  void *external = (void *) &stub;
 
-    {
-      const f_status_t status = f_capability_copy_internal(0, &capability);
+  {
+    const f_status_t status = f_capability_copy_internal(0, &capability);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_capability_copy_internal(external, 0);
+  {
+    const f_status_t status = f_capability_copy_internal(external, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_copy_internal__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-copy_internal.h b/level_0/f_capability/tests/unit/c/test-capability-copy_internal.h
index 3e64b416c0c0488399e30a08a9fe4f09f2004ea0..6cfe51121fa01eae37065ea403a518308575ee4c 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-copy_internal.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-copy_internal.h
@@ -22,9 +22,7 @@ extern void test__f_capability_copy_internal__fails(void **state);
  *
  * @see f_capability_copy_internal()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_copy_internal__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_copy_internal__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-delete.c b/level_0/f_capability/tests/unit/c/test-capability-delete.c
index 5be93ecc8e21947e4ccb74e23c72c013b89d0010..cf453a0f3dbfa8afc6f587cc0b2f4c6f76dcb81c 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-delete.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-delete.c
@@ -34,16 +34,14 @@ void test__f_capability_delete__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_delete__parameter_checking(void **state) {
+void test__f_capability_delete__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_delete(0);
+  {
+    const f_status_t status = f_capability_delete(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_delete__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-delete.h b/level_0/f_capability/tests/unit/c/test-capability-delete.h
index c834362bd9507f0ae87ed82555853d3435ef4104..85c4dac78bbf284b5f8c287113b28cf9c75f39ab 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-delete.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-delete.h
@@ -22,9 +22,7 @@ extern void test__f_capability_delete__fails(void **state);
  *
  * @see f_capability_delete()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_delete__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_delete__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c
index 11c3e9624f9fb3e2f72247aa2c5742541f1f2fb9..c531bf9a8c21a256120b12f672b812055b92fda8 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.c
@@ -47,18 +47,16 @@ void test__f_capability_file_descriptor_get__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_file_descriptor_get__parameter_checking(void **state) {
+void test__f_capability_file_descriptor_get__parameter_checking(void **state) {
 
-    const int descriptor = 0;
+  const int descriptor = 0;
 
-    {
-      const f_status_t status = f_capability_file_descriptor_get(descriptor, 0);
+  {
+    const f_status_t status = f_capability_file_descriptor_get(descriptor, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_file_descriptor_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.h b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.h
index e7df00f70a3a1a9daea65819688b65a650cf8828..ca8eb6e5a481639301c9a4cf8dc642d76399ce6d 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_descriptor_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_file_descriptor_get__fails(void **state);
  *
  * @see f_capability_file_descriptor_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_file_descriptor_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_file_descriptor_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_get.c b/level_0/f_capability/tests/unit/c/test-capability-file_get.c
index 0af59dc1628f3d22418c58aaf770971d40b74ccd..79ad9aa32af2865c639d5f6f7be9eb95810b7a88 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_get.c
@@ -47,18 +47,16 @@ void test__f_capability_file_get__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_file_get__parameter_checking(void **state) {
+void test__f_capability_file_get__parameter_checking(void **state) {
 
   const f_string_static_t path = f_string_static_t_initialize;
 
-    {
-      const f_status_t status = f_capability_file_get(path, 0);
+  {
+    const f_status_t status = f_capability_file_get(path, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_file_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-file_get.h b/level_0/f_capability/tests/unit/c/test-capability-file_get.h
index c61bfecca726de862875b526cdb8855e27795d37..44b24ec67ffff59f806cb428a0e74dac5e270da4 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-file_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-file_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_file_get__fails(void **state);
  *
  * @see f_capability_file_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_file_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_file_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-flag_get.c b/level_0/f_capability/tests/unit/c/test-capability-flag_get.c
index 9815643d8d565274a61c1d449b2a20ba921d7a29..97d3e01d08b497cc9d61b359f704eed4f93b2a21 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-flag_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-flag_get.c
@@ -35,20 +35,18 @@ void test__f_capability_flag_get__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_flag_get__parameter_checking(void **state) {
+void test__f_capability_flag_get__parameter_checking(void **state) {
 
-    const f_capability_flag_t flag = f_capability_flag_t_initialize;
-    const f_capability_t capability = f_capability_t_initialize;
-    const f_capability_value_t capability_value = f_capability_value_t_initialize;
+  const f_capability_flag_t flag = f_capability_flag_t_initialize;
+  const f_capability_t capability = f_capability_t_initialize;
+  const f_capability_value_t capability_value = f_capability_value_t_initialize;
 
-    {
-      const f_status_t status = f_capability_flag_get(capability, capability_value, flag, 0);
+  {
+    const f_status_t status = f_capability_flag_get(capability, capability_value, flag, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_flag_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-flag_get.h b/level_0/f_capability/tests/unit/c/test-capability-flag_get.h
index f1f8d6e26bd58e29b6aae532efa926dab9ce3348..a0faf8ffa1e68ed3b9b90dee6dc11c34b9f2bd40 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-flag_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-flag_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_flag_get__fails(void **state);
  *
  * @see f_capability_flag_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_flag_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_flag_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-flag_set.c b/level_0/f_capability/tests/unit/c/test-capability-flag_set.c
index fc5c50cc9a63a70ce539244ee6e993ef9f1ba5c3..d00e6cb369167ce532655cf9d96e148d9bcf725b 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-flag_set.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-flag_set.c
@@ -35,20 +35,18 @@ void test__f_capability_flag_set__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_flag_set__parameter_checking(void **state) {
+void test__f_capability_flag_set__parameter_checking(void **state) {
 
-    const f_capability_flag_t flag = f_capability_flag_t_initialize;
-    const f_capability_flag_value_t value = f_capability_flag_value_t_initialize;
-    const f_int32s_t codes = f_int32s_t_initialize;
+  const f_capability_flag_t flag = f_capability_flag_t_initialize;
+  const f_capability_flag_value_t value = f_capability_flag_value_t_initialize;
+  const f_int32s_t codes = f_int32s_t_initialize;
 
-    {
-      const f_status_t status = f_capability_flag_set(flag, value, codes, 0);
+  {
+    const f_status_t status = f_capability_flag_set(flag, value, codes, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_flag_set__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-flag_set.h b/level_0/f_capability/tests/unit/c/test-capability-flag_set.h
index ce3ab952b32bf92de72675bf25e6808ce7bad1af..877acc0f7215081fb62a27373aa956f63b318d28 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-flag_set.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-flag_set.h
@@ -22,9 +22,7 @@ extern void test__f_capability_flag_set__fails(void **state);
  *
  * @see f_capability_flag_set()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_flag_set__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_flag_set__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-from_name.c b/level_0/f_capability/tests/unit/c/test-capability-from_name.c
index 2cf9a6d24567594f1e8bface15dc6c4ecdf6accb..c332a91045ff2ff9f9e4f91d6dcf9980b41e8d00 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-from_name.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-from_name.c
@@ -35,18 +35,16 @@ void test__f_capability_from_name__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_from_name__parameter_checking(void **state) {
+void test__f_capability_from_name__parameter_checking(void **state) {
 
-    const f_string_static_t name = f_string_static_t_initialize;
+  const f_string_static_t name = f_string_static_t_initialize;
 
-    {
-      const f_status_t status = f_capability_from_name(name, 0);
+  {
+    const f_status_t status = f_capability_from_name(name, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_from_name__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-from_name.h b/level_0/f_capability/tests/unit/c/test-capability-from_name.h
index 0a6ba81c8e7a084cde86b0ee00e14b518dc69cb6..8b6efb1036bdc9149193f2bda6172c4af8b01f33 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-from_name.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-from_name.h
@@ -22,9 +22,7 @@ extern void test__f_capability_from_name__fails(void **state);
  *
  * @see f_capability_from_name()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_from_name__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_from_name__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-from_text.c b/level_0/f_capability/tests/unit/c/test-capability-from_text.c
index 7e92a9de7de2cbade434832796fbede7527d3b8b..65f2a3b751015cb501c9bab44fd8a7dc4b3c9211 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-from_text.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-from_text.c
@@ -35,18 +35,16 @@ void test__f_capability_from_text__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_from_text__parameter_checking(void **state) {
+void test__f_capability_from_text__parameter_checking(void **state) {
 
-    const f_string_static_t text = f_string_static_t_initialize;
+  const f_string_static_t text = f_string_static_t_initialize;
 
-    {
-      const f_status_t status = f_capability_from_text(text, 0);
+  {
+    const f_status_t status = f_capability_from_text(text, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_from_text__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-from_text.h b/level_0/f_capability/tests/unit/c/test-capability-from_text.h
index 0179fc5c82099b58d02d5aad9bc36ed8dde87da9..65e07887aa87230f3bac2542d4911d471c4eb961 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-from_text.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-from_text.h
@@ -22,9 +22,7 @@ extern void test__f_capability_from_text__fails(void **state);
  *
  * @see f_capability_from_text()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_from_text__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_from_text__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-initialize.c b/level_0/f_capability/tests/unit/c/test-capability-initialize.c
index 004227bbc2ce35f786d4220c305ae66f1fbba316..79300dafe2030a64a8a7745d13d7cd3d7d99ff0f 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-initialize.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-initialize.c
@@ -34,16 +34,14 @@ void test__f_capability_initialize__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_initialize__parameter_checking(void **state) {
+void test__f_capability_initialize__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_initialize(0);
+  {
+    const f_status_t status = f_capability_initialize(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_initialize__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-initialize.h b/level_0/f_capability/tests/unit/c/test-capability-initialize.h
index bfacec0e016a3628f453de65842517c38b42e540..0c626ec097caa7ec7def9a86009c1c4efa9f07c3 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-initialize.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-initialize.h
@@ -22,9 +22,7 @@ extern void test__f_capability_initialize__fails(void **state);
  *
  * @see f_capability_initialize()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_initialize__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_initialize__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_get.c b/level_0/f_capability/tests/unit/c/test-capability-mode_get.c
index 9f704ee24f58acbf204ce84977bf4c656084ac73..58d9933bfa97bf840cd6ed52071867b178439a62 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_get.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_mode_get__parameter_checking(void **state) {
+void test__f_capability_mode_get__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_mode_get(0);
+  {
+    const f_status_t status = f_capability_mode_get(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_mode_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_get.h b/level_0/f_capability/tests/unit/c/test-capability-mode_get.h
index 269b9990e3d70ef22274a425f389786f2e97b313..5214ba3573e7f830b8d4969e8f0109936086c2c2 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_get.h
@@ -17,9 +17,7 @@
  *
  * @see f_capability_mode_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_mode_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_mode_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c b/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c
index 88c216af534ed0a52e706301612b3f4f91dc2f52..79c576afaa0657da52fd24800b68a70f80d6eec3 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.c
@@ -5,18 +5,16 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_mode_get_name__parameter_checking(void **state) {
+void test__f_capability_mode_get_name__parameter_checking(void **state) {
 
-    const f_capability_mode_t mode = f_capability_mode_t_initialize;
+  const f_capability_mode_t mode = f_capability_mode_t_initialize;
 
-    {
-      const f_status_t status = f_capability_mode_get_name(mode, 0);
+  {
+    const f_status_t status = f_capability_mode_get_name(mode, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_mode_get_name__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.h b/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.h
index abc3b70cb161b06cece03751b6936c0c0e618b28..a1ab83fb33508cbe043e586f077fbf3fd3f69d75 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-mode_get_name.h
@@ -17,9 +17,7 @@
  *
  * @see f_capability_mode_get_name()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_mode_get_name__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_mode_get_name__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-owner_get.c b/level_0/f_capability/tests/unit/c/test-capability-owner_get.c
index f03f54599e595416f8f106c5e4ca7173b4e0efb0..949fadc0f4a7a7a9d1595600da90a749707cce9a 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-owner_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-owner_get.c
@@ -5,18 +5,16 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_owner_get__parameter_checking(void **state) {
+void test__f_capability_owner_get__parameter_checking(void **state) {
 
-    const f_capability_t capability = f_capability_t_initialize;
+  const f_capability_t capability = f_capability_t_initialize;
 
-    {
-      const f_status_t status = f_capability_owner_get(capability, 0);
+  {
+    const f_status_t status = f_capability_owner_get(capability, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_owner_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-owner_get.h b/level_0/f_capability/tests/unit/c/test-capability-owner_get.h
index ad5d8f6e24f7e5b45df626af212478abcdcfd1cb..20d75c5f763a7110fb9003462732830c277a07e0 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-owner_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-owner_get.h
@@ -17,9 +17,7 @@
  *
  * @see f_capability_owner_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_owner_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_owner_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c b/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c
index f487425e9bfe2f18bc8f1348051772144b158157..e2041fec239f58df6ca10425a2209f8c3d93fc52 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.c
@@ -37,18 +37,16 @@ void test__f_capability_process_bound_drop__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_process_bound_drop__parameter_checking(void **state) {
+void test__f_capability_process_bound_drop__parameter_checking(void **state) {
 
-    const f_capability_value_t value = f_capability_value_t_initialize;
+  const f_capability_value_t value = f_capability_value_t_initialize;
 
-    {
-      const f_status_t status = f_capability_process_bound_drop(value, 0);
+  {
+    const f_status_t status = f_capability_process_bound_drop(value, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_process_bound_drop__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.h b/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.h
index b84b135982dce15f07fc0d74ffdb9bc7093f2c23..b62e347bfd44b43b742382c0d16a78afa891934b 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_bound_drop.h
@@ -22,9 +22,7 @@ extern void test__f_capability_process_bound_drop__fails(void **state);
  *
  * @see f_capability_process_bound_drop()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_process_bound_drop__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_process_bound_drop__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c b/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c
index 7810c8c5f39652e3d6ccdb1d57667caded6a7dff..8fd02d71a0dfb8c72cf78ba48a21ac3ac86a25b2 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.c
@@ -31,18 +31,16 @@ void test__f_capability_process_bound_get__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_process_bound_get__parameter_checking(void **state) {
+void test__f_capability_process_bound_get__parameter_checking(void **state) {
 
-    const f_capability_value_t value = f_capability_value_t_initialize;
+  const f_capability_value_t value = f_capability_value_t_initialize;
 
-    {
-      const f_status_t status = f_capability_process_bound_get(value, 0);
+  {
+    const f_status_t status = f_capability_process_bound_get(value, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_process_bound_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.h b/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.h
index c66aac60e26930446574ce57ccdc9e2c659e7c6a..999b354e1482f6ee0bbc69be1335d90beae94487 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_bound_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_process_bound_get__fails(void **state);
  *
  * @see f_capability_process_bound_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_process_bound_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_process_bound_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_get.c b/level_0/f_capability/tests/unit/c/test-capability-process_get.c
index baf37bfee3575d5262e9794f010eb987a0fed44e..81215f48cf818e17f9d2c0d1acce7b9eae587dc1 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_get.c
@@ -34,16 +34,14 @@ void test__f_capability_process_get__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_process_get__parameter_checking(void **state) {
+void test__f_capability_process_get__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_process_get(0);
+  {
+    const f_status_t status = f_capability_process_get(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_process_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_get.h b/level_0/f_capability/tests/unit/c/test-capability-process_get.h
index 314c2e045e57559ac16c1487c95e45bcf0fcbb8f..8c311338fa2d5cdab59d1155664438e0e2bbe36f 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_process_get__fails(void **state);
  *
  * @see f_capability_process_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_process_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_process_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c b/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c
index bb22ad0075f7cc7a8f6b20aa25d282f986cacd90..a85481bcbf8bcbd7745ad029b48fb9b1d51d62b7 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.c
@@ -31,16 +31,14 @@ void test__f_capability_process_get_by_id__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_process_get_by_id__parameter_checking(void **state) {
+void test__f_capability_process_get_by_id__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_process_get_by_id(0, 0);
+  {
+    const f_status_t status = f_capability_process_get_by_id(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_process_get_by_id__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.h b/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.h
index 68e0bad20e79db9e48a52cf1d185d2c6b7838c75..cdd1b5270d66b16cce9598ecfa23ebc2b510510f 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-process_get_by_id.h
@@ -22,9 +22,7 @@ extern void test__f_capability_process_get_by_id__fails(void **state);
  *
  * @see f_capability_process_get_by_id()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_process_get_by_id__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_process_get_by_id__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c b/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c
index ceed1729979e7240731139819bcf02f7c09ae023..fc63302ee0e4f18f0b9b316d0691cf2bdc870b58 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.c
@@ -36,16 +36,14 @@ void test__f_capability_security_bits_get__fails(void **state) {
   #endif // !defined(_di_libcap_) && !defined(_libcap_legacy_only_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_security_bits_get__parameter_checking(void **state) {
+void test__f_capability_security_bits_get__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_capability_security_bits_get(0);
+  {
+    const f_status_t status = f_capability_security_bits_get(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_security_bits_get__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.h b/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.h
index 1d86a894905ee503ee07a0f9c413e848a756aad0..db60314e538b1f54d2c280ed871974f6c2f36caa 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-security_bits_get.h
@@ -22,9 +22,7 @@ extern void test__f_capability_security_bits_get__fails(void **state);
  *
  * @see f_capability_security_bits_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_security_bits_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_security_bits_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-size.c b/level_0/f_capability/tests/unit/c/test-capability-size.c
index c7c2d6cd44df0c8fa4d43dc8a0d96bd49ca304c0..b29ffb5b4ce0067c1d17112b771c0294f3883d9d 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-size.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-size.c
@@ -37,18 +37,16 @@ void test__f_capability_size__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_size__parameter_checking(void **state) {
+void test__f_capability_size__parameter_checking(void **state) {
 
-    const f_capability_t capability = f_capability_t_initialize;
+  const f_capability_t capability = f_capability_t_initialize;
 
-    {
-      const f_status_t status = f_capability_size(capability, 0);
+  {
+    const f_status_t status = f_capability_size(capability, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_size__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-size.h b/level_0/f_capability/tests/unit/c/test-capability-size.h
index 1896df7c240c8757be22a5c64680b122769bfc62..35baec5edfc49a0bf38b7fd6c0d5c94e730b2528 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-size.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-size.h
@@ -22,9 +22,7 @@ extern void test__f_capability_size__fails(void **state);
  *
  * @see f_capability_size()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_size__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_size__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-to_name.c b/level_0/f_capability/tests/unit/c/test-capability-to_name.c
index 581a300fe8d947500e2e77027633e809bb88763f..4815fca2d769398b73670ca3602c924d1b32c0f0 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-to_name.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-to_name.c
@@ -36,18 +36,16 @@ void test__f_capability_to_name__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_to_name__parameter_checking(void **state) {
+void test__f_capability_to_name__parameter_checking(void **state) {
 
-    const int code = CAP_CHOWN;
+  const int code = CAP_CHOWN;
 
-    {
-      const f_status_t status = f_capability_to_name(code, 0);
+  {
+    const f_status_t status = f_capability_to_name(code, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_to_name__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-to_name.h b/level_0/f_capability/tests/unit/c/test-capability-to_name.h
index 639ba3bce33a6cb41876eed852b7db3de7c25044..79fb97cf004845e9684ac6a8cf21d4221ae26e26 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-to_name.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-to_name.h
@@ -22,9 +22,7 @@ extern void test__f_capability_to_name__fails(void **state);
  *
  * @see f_capability_to_name()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_to_name__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_to_name__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability-to_text.c b/level_0/f_capability/tests/unit/c/test-capability-to_text.c
index 0d0416eb780bb3f069c7639457dd29d79e086ce5..2d8d3bd357654ed20bdbd01e711875b1ab309659 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-to_text.c
+++ b/level_0/f_capability/tests/unit/c/test-capability-to_text.c
@@ -36,18 +36,16 @@ void test__f_capability_to_text__fails(void **state) {
   #endif // !defined(_di_libcap_)
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_capability_to_text__parameter_checking(void **state) {
+void test__f_capability_to_text__parameter_checking(void **state) {
 
-    const f_capability_t capability = f_capability_t_initialize;
+  const f_capability_t capability = f_capability_t_initialize;
 
-    {
-      const f_status_t status = f_capability_to_text(capability, 0);
+  {
+    const f_status_t status = f_capability_to_text(capability, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_capability_to_text__works(void **state) {
 

diff --git a/level_0/f_capability/tests/unit/c/test-capability-to_text.h b/level_0/f_capability/tests/unit/c/test-capability-to_text.h
index 2adc8ef3c8e94de04753ebcec9c393956b65e072..5a8698864425f9256849cc4da8a87303883a823f 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability-to_text.h
+++ b/level_0/f_capability/tests/unit/c/test-capability-to_text.h
@@ -22,9 +22,7 @@ extern void test__f_capability_to_text__fails(void **state);
  *
  * @see f_capability_to_text()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_capability_to_text__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_capability_to_text__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_capability/tests/unit/c/test-capability.c b/level_0/f_capability/tests/unit/c/test-capability.c
index 4a2dbe63ebef111a347854e0a6e77968df1a27e5..f9de116c7089e44b9ff144d1ca02edec7cd1ff6b 100644 (file)
--- a/level_0/f_capability/tests/unit/c/test-capability.c
+++ b/level_0/f_capability/tests/unit/c/test-capability.c
@@ -79,16 +79,13 @@ int main(void) {
     cmocka_unit_test(test__f_capability_initialize__fails),
     cmocka_unit_test(test__f_capability_initialize__works),
 
-    // cap_get_mode() doesn't return failure.
     cmocka_unit_test(test__f_capability_mode_get__works),
 
-    // cap_mode_name() doesn't return failure.
     cmocka_unit_test(test__f_capability_mode_get_name__works),
 
     cmocka_unit_test(test__f_capability_mode_set__fails),
     cmocka_unit_test(test__f_capability_mode_set__works),
 
-    // cap_get_nsowner() doesn't return failure.
     cmocka_unit_test(test__f_capability_owner_get__works),
 
     cmocka_unit_test(test__f_capability_owner_set__fails),
@@ -118,13 +115,10 @@ int main(void) {
     cmocka_unit_test(test__f_capability_size__fails),
     cmocka_unit_test(test__f_capability_size__works),
 
-    // f_capability_supported() doesn't return failure.
     cmocka_unit_test(test__f_capability_supported__works),
 
-    // f_capability_supported_ambient() doesn't return failure.
     cmocka_unit_test(test__f_capability_supported_ambient__works),
 
-    // f_capability_supported_code() doesn't return failure.
     cmocka_unit_test(test__f_capability_supported_code__works),
 
     cmocka_unit_test(test__f_capability_to_name__fails),

diff --git a/level_0/f_color/tests/unit/c/test-color-context_delete.c b/level_0/f_color/tests/unit/c/test-color-context_delete.c
index fdc069be7e01f3af0f63d9c36f81cca0f9c3b564..bbbe942160e464000f56e8a777a87eb9dc1870c5 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-context_delete.c
+++ b/level_0/f_color/tests/unit/c/test-color-context_delete.c
@@ -108,16 +108,14 @@ void test__f_color_context_delete__frees_memory(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_context_delete__parameter_checking(void **state) {
+void test__f_color_context_delete__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_color_context_delete(0);
+  {
+    const f_status_t status = f_color_context_delete(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 #ifdef __cplusplus
 } // extern "C"

diff --git a/level_0/f_color/tests/unit/c/test-color-context_delete.h b/level_0/f_color/tests/unit/c/test-color-context_delete.h
index 4355f72aee0e02a827edaa636e4b3f3b63d237a2..af4537a99c0ad92d34d3e4b235abc83be3ec693c 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-context_delete.h
+++ b/level_0/f_color/tests/unit/c/test-color-context_delete.h
@@ -22,8 +22,6 @@ extern void test__f_color_context_delete__frees_memory(void **state);
  *
  * @see f_color_context_delete()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_context_delete__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_context_delete__parameter_checking(void **state);
 
 #endif // _TEST__F_color__delete

diff --git a/level_0/f_color/tests/unit/c/test-color-context_destroy.c b/level_0/f_color/tests/unit/c/test-color-context_destroy.c
index e5ff81200a00bf991b88d2bd6b4113617b389ec3..c85acd32953494148a0ae5ef4ac2d85765b0405b 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-context_destroy.c
+++ b/level_0/f_color/tests/unit/c/test-color-context_destroy.c
@@ -108,16 +108,14 @@ void test__f_color_context_destroy__frees_memory(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_context_destroy__parameter_checking(void **state) {
+void test__f_color_context_destroy__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_color_context_destroy(0);
+  {
+    const f_status_t status = f_color_context_destroy(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 #ifdef __cplusplus
 } // extern "C"

diff --git a/level_0/f_color/tests/unit/c/test-color-context_destroy.h b/level_0/f_color/tests/unit/c/test-color-context_destroy.h
index a5cabbfda0f555e039a42c0e6305aa191475f82b..64bef846c6e64973fd4fdce044004119e03f96e8 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-context_destroy.h
+++ b/level_0/f_color/tests/unit/c/test-color-context_destroy.h
@@ -22,8 +22,6 @@ extern void test__f_color_context_destroy__frees_memory(void **state);
  *
  * @see f_color_context_destroy()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_context_destroy__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_context_destroy__parameter_checking(void **state);
 
 #endif // _TEST__F_color__destroy

diff --git a/level_0/f_color/tests/unit/c/test-color-load_context.c b/level_0/f_color/tests/unit/c/test-color-load_context.c
index 79b9e652039b4538db2a960599ac65d8b44c231b..3799bda5be73cc90241fce3ca1c958b507d25a28 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-load_context.c
+++ b/level_0/f_color/tests/unit/c/test-color-load_context.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_load_context__parameter_checking(void **state) {
+void test__f_color_load_context__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_color_load_context(F_true, 0);
+  {
+    const f_status_t status = f_color_load_context(F_true, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_color_load_context__works(void **state) {
 

diff --git a/level_0/f_color/tests/unit/c/test-color-load_context.h b/level_0/f_color/tests/unit/c/test-color-load_context.h
index 3ecf4a6d21dc2a155677661724b8934ab4b63383..0da2172ef1da21acf6ba3b2b992a237f0e9dce77 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-load_context.h
+++ b/level_0/f_color/tests/unit/c/test-color-load_context.h
@@ -17,9 +17,7 @@
  *
  * @see f_color_load_context()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_load_context__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_load_context__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_color/tests/unit/c/test-color-save_1.c b/level_0/f_color/tests/unit/c/test-color-save_1.c
index e9db186aa6d641db32219f0677eabbdbef330ee0..7db5cf7c5e66b7630c1cd1ef42f5f47d63ad9f2b 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_1.c
+++ b/level_0/f_color/tests/unit/c/test-color-save_1.c
@@ -5,19 +5,17 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_save_1_parameter_checking(void **state) {
+void test__f_color_save_1_parameter_checking(void **state) {
 
-    const f_color_format_t format = f_color_format_t_initialize;
-    const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
+  const f_color_format_t format = f_color_format_t_initialize;
+  const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
 
-    {
-      const f_status_t status = f_color_save_1(format, color, 0);
+  {
+    const f_status_t status = f_color_save_1(format, color, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_color_save_1_works(void **state) {
 

diff --git a/level_0/f_color/tests/unit/c/test-color-save_1.h b/level_0/f_color/tests/unit/c/test-color-save_1.h
index d80b485a35a33e7e6b57c5e6d40926347224f53e..afc11fe886c427693b01dd450ad0dedab263477d 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_1.h
+++ b/level_0/f_color/tests/unit/c/test-color-save_1.h
@@ -17,9 +17,7 @@
  *
  * @see f_color_save_1()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_save_1_parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_save_1_parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_color/tests/unit/c/test-color-save_2.c b/level_0/f_color/tests/unit/c/test-color-save_2.c
index ffb476ffe3e820a9df2d11ef3dcb3bef16eafe52..3c3f806b74744b29f481b86bf3d155234fa96ec7 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_2.c
+++ b/level_0/f_color/tests/unit/c/test-color-save_2.c
@@ -5,19 +5,17 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_save_2_parameter_checking(void **state) {
+void test__f_color_save_2_parameter_checking(void **state) {
 
-    const f_color_format_t format = f_color_format_t_initialize;
-    const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
+  const f_color_format_t format = f_color_format_t_initialize;
+  const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
 
-    {
-      const f_status_t status = f_color_save_2(format, color, color, 0);
+  {
+    const f_status_t status = f_color_save_2(format, color, color, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_color_save_2_works(void **state) {
 

diff --git a/level_0/f_color/tests/unit/c/test-color-save_2.h b/level_0/f_color/tests/unit/c/test-color-save_2.h
index 69c442275a3cdae4c6b6bf61217b26647774458b..0d47320db6d814811880a351a957dafe8d8db654 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_2.h
+++ b/level_0/f_color/tests/unit/c/test-color-save_2.h
@@ -17,9 +17,7 @@
  *
  * @see f_color_save_2()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_save_2_parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_save_2_parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_color/tests/unit/c/test-color-save_3.c b/level_0/f_color/tests/unit/c/test-color-save_3.c
index fe6996d515e517be26741f5453643ab00277e512..d015b2c38dbd3b0eb6b1eb32384ddefbb4e2f93d 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_3.c
+++ b/level_0/f_color/tests/unit/c/test-color-save_3.c
@@ -5,19 +5,17 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_save_3_parameter_checking(void **state) {
+void test__f_color_save_3_parameter_checking(void **state) {
 
-    const f_color_format_t format = f_color_format_t_initialize;
-    const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
+  const f_color_format_t format = f_color_format_t_initialize;
+  const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
 
-    {
-      const f_status_t status = f_color_save_3(format, color, color, color, 0);
+  {
+    const f_status_t status = f_color_save_3(format, color, color, color, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_color_save_3_works(void **state) {
 

diff --git a/level_0/f_color/tests/unit/c/test-color-save_3.h b/level_0/f_color/tests/unit/c/test-color-save_3.h
index 33b874e9b95df1acaa6b96ddea56a8ebbdaf960e..493cc3a2a63fc42bbb6b2c3242c16b28f4ba33e9 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_3.h
+++ b/level_0/f_color/tests/unit/c/test-color-save_3.h
@@ -17,9 +17,7 @@
  *
  * @see f_color_save_3()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_save_3_parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_save_3_parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_color/tests/unit/c/test-color-save_4.c b/level_0/f_color/tests/unit/c/test-color-save_4.c
index 98fd1bd3437ddc65a94bc40d5f024eddb44b5635..0117955c0ab7060441e3ee928ba3f35a71b67c83 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_4.c
+++ b/level_0/f_color/tests/unit/c/test-color-save_4.c
@@ -5,19 +5,17 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_save_4_parameter_checking(void **state) {
+void test__f_color_save_4_parameter_checking(void **state) {
 
-    const f_color_format_t format = f_color_format_t_initialize;
-    const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
+  const f_color_format_t format = f_color_format_t_initialize;
+  const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
 
-    {
-      const f_status_t status = f_color_save_4(format, color, color, color, color, 0);
+  {
+    const f_status_t status = f_color_save_4(format, color, color, color, color, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_color_save_4_works(void **state) {
 

diff --git a/level_0/f_color/tests/unit/c/test-color-save_4.h b/level_0/f_color/tests/unit/c/test-color-save_4.h
index cf177ef8eeeb003d47c3f5090b7b89cadd230476..881df7e1a78215464618cc99b5ac1ffe4806850a 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_4.h
+++ b/level_0/f_color/tests/unit/c/test-color-save_4.h
@@ -17,9 +17,7 @@
  *
  * @see f_color_save_4()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_save_4_parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_save_4_parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_color/tests/unit/c/test-color-save_5.c b/level_0/f_color/tests/unit/c/test-color-save_5.c
index e3bf534dbbe88d988e6d510eb9d2a663629f12de..bd0b1a0588bca55fc90afd7ae0bd49b8a1062532 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_5.c
+++ b/level_0/f_color/tests/unit/c/test-color-save_5.c
@@ -5,19 +5,17 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_color_save_5_parameter_checking(void **state) {
+void test__f_color_save_5_parameter_checking(void **state) {
 
-    const f_color_format_t format = f_color_format_t_initialize;
-    const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
+  const f_color_format_t format = f_color_format_t_initialize;
+  const f_string_static_t color = macro_f_string_static_t_initialize2("color", 5);
 
-    {
-      const f_status_t status = f_color_save_5(format, color, color, color, color, color, 0);
+  {
+    const f_status_t status = f_color_save_5(format, color, color, color, color, color, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_color_save_5_works(void **state) {
 

diff --git a/level_0/f_color/tests/unit/c/test-color-save_5.h b/level_0/f_color/tests/unit/c/test-color-save_5.h
index 6bc2aadbe6690eded1219911f97eef9aadf56ebe..6e60dc87a6c40fba922670d17a4fb955673e3798 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color-save_5.h
+++ b/level_0/f_color/tests/unit/c/test-color-save_5.h
@@ -17,9 +17,7 @@
  *
  * @see f_color_save_5()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_color_save_5_parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_color_save_5_parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_color/tests/unit/c/test-color.c b/level_0/f_color/tests/unit/c/test-color.c
index b3c70b3f4fb8e27607993043794726bb57e6cf4e..859412b833a936093516a678a7e99870e0536940 100644 (file)
--- a/level_0/f_color/tests/unit/c/test-color.c
+++ b/level_0/f_color/tests/unit/c/test-color.c
@@ -20,22 +20,16 @@ int main(void) {
 
   const struct CMUnitTest tests[] = {
 
-    // f_color_load_context() only returns failures by other functions that have their own tests.
     cmocka_unit_test(test__f_color_load_context__works),
 
-    // f_color_save_1() only returns failures by other functions that have their own tests.
     cmocka_unit_test(test__f_color_save_1_works),
 
-    // f_color_save_2() only returns failures by other functions that have their own tests.
     cmocka_unit_test(test__f_color_save_2_works),
 
-    // f_color_save_3() only returns failures by other functions that have their own tests.
     cmocka_unit_test(test__f_color_save_3_works),
 
-    // f_color_save_4() only returns failures by other functions that have their own tests.
     cmocka_unit_test(test__f_color_save_4_works),
 
-    // f_color_save_5() only returns failures by other functions that have their own tests.
     cmocka_unit_test(test__f_color_save_5_works),
 
     cmocka_unit_test(test__f_color_context_delete__frees_memory),

diff --git a/level_0/f_console/tests/unit/c/test-console-environment_process.c b/level_0/f_console/tests/unit/c/test-console-environment_process.c
index 0ad0ce87678b61bc380a084bd4adb4f2e01b9f79..e959e10541fc6c9c099c79783acc2d825cbf652b 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-environment_process.c
+++ b/level_0/f_console/tests/unit/c/test-console-environment_process.c
@@ -27,18 +27,16 @@ void test__f_console_environment_process__data_not(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_environment_process__parameter_checking(void **state) {
+void test__f_console_environment_process__parameter_checking(void **state) {
 
-    const f_console_arguments_t arguments = f_console_arguments_t_initialize;
+  const f_console_arguments_t arguments = f_console_arguments_t_initialize;
 
-    {
-      const f_status_t status = f_console_environment_process(arguments, 0);
+  {
+    const f_status_t status = f_console_environment_process(arguments, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_console_environment_process__works(void **state) {
 

diff --git a/level_0/f_console/tests/unit/c/test-console-environment_process.h b/level_0/f_console/tests/unit/c/test-console-environment_process.h
index 35a8e506f017260b73eac9efa29126a46c727c35..1c9b1b3aa7e90ff5c276490c96a5010216f9022f 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-environment_process.h
+++ b/level_0/f_console/tests/unit/c/test-console-environment_process.h
@@ -24,9 +24,7 @@ extern void test__f_console_environment_process__data_not(void **state);
  *
  * @see f_console_environment_process()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_environment_process__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_environment_process__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_console/tests/unit/c/test-console-identify.c b/level_0/f_console/tests/unit/c/test-console-identify.c
index 03515fa92b57dc2a602a7551d36f656037c3f76c..07dae402d4d6888016c4ee4379e7ae0cc370a5f7 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-identify.c
+++ b/level_0/f_console/tests/unit/c/test-console-identify.c
@@ -5,18 +5,16 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_identify__parameter_checking(void **state) {
+void test__f_console_identify__parameter_checking(void **state) {
 
-    const f_string_t input = f_string_t_initialize;
+  const f_string_t input = f_string_t_initialize;
 
-    {
-      const f_status_t status = f_console_identify(input, 0);
+  {
+    const f_status_t status = f_console_identify(input, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_console_identify__works(void **state) {
 

diff --git a/level_0/f_console/tests/unit/c/test-console-identify.h b/level_0/f_console/tests/unit/c/test-console-identify.h
index 11d6ec17cf3c745511ad3c09662229824223ecbb..4aa9ba8c11e8cf27270545946bc3f0dda16e144f 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-identify.h
+++ b/level_0/f_console/tests/unit/c/test-console-identify.h
@@ -17,9 +17,7 @@
  *
  * @see f_console_identify()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_identify__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_identify__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.c b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.c
index fe0927232e3f1ef5c79a55b631073d5c834a8fd5..ff388335d982e315b1501344d64d6d168208b6d1 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.c
+++ b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.c
@@ -29,30 +29,28 @@ void test__f_console_parameter_prioritize_left__fails(void **state) {
   f_console_parameters_delete(&parameters);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_parameter_prioritize_left__parameter_checking(void **state) {
+void test__f_console_parameter_prioritize_left__parameter_checking(void **state) {
 
-    f_console_parameters_t parameters = f_console_parameters_t_initialize;
-    f_console_parameter_ids_t choices = f_console_parameter_ids_t_initialize;
-
-    {
-      const f_status_t status = f_console_parameter_prioritize_left(parameters, choices, 0);
+  f_console_parameters_t parameters = f_console_parameters_t_initialize;
+  f_console_parameter_ids_t choices = f_console_parameter_ids_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_console_parameter_prioritize_left(parameters, choices, 0);
 
-    {
-      f_console_parameter_id_t ids_array[1] = { f_console_parameter_id_t_initialize };
-      choices.id = ids_array;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-      const f_status_t status = f_console_parameter_prioritize_left(parameters, choices, 0);
+  {
+    f_console_parameter_id_t ids_array[1] = { f_console_parameter_id_t_initialize };
+    choices.id = ids_array;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    const f_status_t status = f_console_parameter_prioritize_left(parameters, choices, 0);
 
-    f_console_parameters_delete(&parameters);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_console_parameters_delete(&parameters);
+}
 
 void test__f_console_parameter_prioritize_left__works(void **state) {
 

diff --git a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.h b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.h
index 609ffae81396ef3a1a4da89634604d4b176b86a7..371c13f09b255c37f0a808d9f54810ef3328ecb2 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.h
+++ b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_left.h
@@ -22,9 +22,7 @@ extern void test__f_console_parameter_prioritize_left__fails(void **state);
  *
  * @see f_console_parameter_prioritize_left()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_parameter_prioritize_left__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_parameter_prioritize_left__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.c b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.c
index 97917d9e91e7e7f007762d8d6f9db72bec78c7b4..9e0186047d3a9ad5c2c885bc9e0dbbe0b3e65261 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.c
+++ b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.c
@@ -29,30 +29,28 @@ void test__f_console_parameter_prioritize_right__fails(void **state) {
   f_console_parameters_delete(&parameters);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_parameter_prioritize_right__parameter_checking(void **state) {
+void test__f_console_parameter_prioritize_right__parameter_checking(void **state) {
 
-    f_console_parameters_t parameters = f_console_parameters_t_initialize;
-    f_console_parameter_ids_t choices = f_console_parameter_ids_t_initialize;
-
-    {
-      const f_status_t status = f_console_parameter_prioritize_right(parameters, choices, 0);
+  f_console_parameters_t parameters = f_console_parameters_t_initialize;
+  f_console_parameter_ids_t choices = f_console_parameter_ids_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_console_parameter_prioritize_right(parameters, choices, 0);
 
-    {
-      f_console_parameter_id_t ids_array[1] = { f_console_parameter_id_t_initialize };
-      choices.id = ids_array;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-      const f_status_t status = f_console_parameter_prioritize_right(parameters, choices, 0);
+  {
+    f_console_parameter_id_t ids_array[1] = { f_console_parameter_id_t_initialize };
+    choices.id = ids_array;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    const f_status_t status = f_console_parameter_prioritize_right(parameters, choices, 0);
 
-    f_console_parameters_delete(&parameters);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_console_parameters_delete(&parameters);
+}
 
 void test__f_console_parameter_prioritize_right__works(void **state) {
 

diff --git a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.h b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.h
index 156bc5944c806f2d3d74fd11d7ae22e83b6a472c..597b1a681baa57c0b9748cff7d53b6fa9722bd88 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.h
+++ b/level_0/f_console/tests/unit/c/test-console-parameter_prioritize_right.h
@@ -22,9 +22,7 @@ extern void test__f_console_parameter_prioritize_right__fails(void **state);
  *
  * @see f_console_parameter_prioritize_right()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_parameter_prioritize_right__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_parameter_prioritize_right__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_console/tests/unit/c/test-console-parameter_process.c b/level_0/f_console/tests/unit/c/test-console-parameter_process.c
index 641f23f46ae90707a1c07a26ada03288c803ff6b..b43f48e7a935306683ace7dd75e6c4f039270b00 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameter_process.c
+++ b/level_0/f_console/tests/unit/c/test-console-parameter_process.c
@@ -370,18 +370,16 @@ void test__f_console_parameter_process__only_remaining(void **state) {
   f_console_parameters_delete(&parameters);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_parameter_process__parameter_checking(void **state) {
+void test__f_console_parameter_process__parameter_checking(void **state) {
 
-    const f_console_arguments_t arguments = f_console_arguments_t_initialize;
+  const f_console_arguments_t arguments = f_console_arguments_t_initialize;
 
-    {
-      const f_status_t status = f_console_parameter_process(arguments, 0);
+  {
+    const f_status_t status = f_console_parameter_process(arguments, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_console_parameter_process__works(void **state) {
 

diff --git a/level_0/f_console/tests/unit/c/test-console-parameter_process.h b/level_0/f_console/tests/unit/c/test-console-parameter_process.h
index 5e9c1724bbc652d8f37ee13ee1aca36d88096a87..51518118f2a753a53fa1b7bfc2dea2cfb5bbba96 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameter_process.h
+++ b/level_0/f_console/tests/unit/c/test-console-parameter_process.h
@@ -45,9 +45,7 @@ extern void test__f_console_parameter_process__only_remaining(void **state);
  *
  * @see f_console_parameter_process()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_parameter_process__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_parameter_process__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_console/tests/unit/c/test-console-parameters_delete.c b/level_0/f_console/tests/unit/c/test-console-parameters_delete.c
index 9129cb05491e0d81921bb619069b3edb446748e1..2f1ac326f8920693eb391c5300a07dd2da28b130 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameters_delete.c
+++ b/level_0/f_console/tests/unit/c/test-console-parameters_delete.c
@@ -50,16 +50,14 @@ void test__f_console_parameters_delete__frees_memory(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_parameters_delete__parameter_checking(void **state) {
+void test__f_console_parameters_delete__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_console_parameters_delete(0);
+  {
+    const f_status_t status = f_console_parameters_delete(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 #ifdef __cplusplus
 } // extern "C"

diff --git a/level_0/f_console/tests/unit/c/test-console-parameters_delete.h b/level_0/f_console/tests/unit/c/test-console-parameters_delete.h
index b15c282217487e44a75ca3f4706165964ce02ce9..b2513757312d14e4178ad8a09b85215186929e7b 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameters_delete.h
+++ b/level_0/f_console/tests/unit/c/test-console-parameters_delete.h
@@ -22,8 +22,6 @@ extern void test__f_console_parameters_delete__frees_memory(void **state);
  *
  * @see f_console_parameters_delete()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_parameters_delete__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_parameters_delete__parameter_checking(void **state);
 
 #endif // _TEST__F_console__delete

diff --git a/level_0/f_console/tests/unit/c/test-console-parameters_destroy.c b/level_0/f_console/tests/unit/c/test-console-parameters_destroy.c
index 825401827aad03fcdd03e3fbddf80c72b2069618..527dbbfc6c7254fb8b295af19adca3209e2857f1 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameters_destroy.c
+++ b/level_0/f_console/tests/unit/c/test-console-parameters_destroy.c
@@ -50,16 +50,14 @@ void test__f_console_parameters_destroy__frees_memory(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_console_parameters_destroy__parameter_checking(void **state) {
+void test__f_console_parameters_destroy__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_console_parameters_destroy(0);
+  {
+    const f_status_t status = f_console_parameters_destroy(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 #ifdef __cplusplus
 } // extern "C"

diff --git a/level_0/f_console/tests/unit/c/test-console-parameters_destroy.h b/level_0/f_console/tests/unit/c/test-console-parameters_destroy.h
index 588e561107294b33de7b52e18416ee13e447896a..48c8a9b4b26d183ea59182fa7928f7bce0af3640 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console-parameters_destroy.h
+++ b/level_0/f_console/tests/unit/c/test-console-parameters_destroy.h
@@ -22,8 +22,6 @@ extern void test__f_console_parameters_destroy__frees_memory(void **state);
  *
  * @see f_console_parameters_destroy()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_console_parameters_destroy__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_console_parameters_destroy__parameter_checking(void **state);
 
 #endif // _TEST__F_console__destroy

diff --git a/level_0/f_console/tests/unit/c/test-console.c b/level_0/f_console/tests/unit/c/test-console.c
index 07b59aa2ca6127f074fba7c0b38f46b71bb4ef9a..055d99eabe3358831ab51ddeab57fcc465a823ab 100644 (file)
--- a/level_0/f_console/tests/unit/c/test-console.c
+++ b/level_0/f_console/tests/unit/c/test-console.c
@@ -20,11 +20,9 @@ int main(void) {
 
   const struct CMUnitTest tests[] = {
 
-    // f_console_environment_process() only returns memory failures.
     cmocka_unit_test(test__f_console_environment_process__data_not),
     cmocka_unit_test(test__f_console_environment_process__works),
 
-    // f_console_identify() doesn't return failure.
     cmocka_unit_test(test__f_console_identify__works),
 
     cmocka_unit_test(test__f_console_parameter_prioritize_left__fails),
@@ -33,7 +31,6 @@ int main(void) {
     cmocka_unit_test(test__f_console_parameter_prioritize_right__fails),
     cmocka_unit_test(test__f_console_parameter_prioritize_right__works),
 
-    // f_console_parameter_process() only returns memory failures.
     cmocka_unit_test(test__f_console_parameter_process__no_arguments_no_program),
     cmocka_unit_test(test__f_console_parameter_process__no_arguments),
     cmocka_unit_test(test__f_console_parameter_process__null_arguments),

diff --git a/level_0/f_control_group/tests/unit/c/test-control_group-copy.c b/level_0/f_control_group/tests/unit/c/test-control_group-copy.c
index 6be257ac496785136f591091a2e058ed70d85a11..17cd08627bc6390dd3f02f1e19348054ba94e4ea 100644 (file)
--- a/level_0/f_control_group/tests/unit/c/test-control_group-copy.c
+++ b/level_0/f_control_group/tests/unit/c/test-control_group-copy.c
@@ -5,18 +5,16 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_control_group_copy__parameter_checking(void **state) {
+void test__f_control_group_copy__parameter_checking(void **state) {
 
-    const f_control_group_t source = f_control_group_t_initialize;
+  const f_control_group_t source = f_control_group_t_initialize;
 
-    {
-      const f_status_t status = f_control_group_copy(source, 0);
+  {
+    const f_status_t status = f_control_group_copy(source, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_control_group_copy__works(void **state) {
 

diff --git a/level_0/f_control_group/tests/unit/c/test-control_group-copy.h b/level_0/f_control_group/tests/unit/c/test-control_group-copy.h
index eeff77a7932c9c255b1903f982980471deb3bf5f..806db5e54f2a2ca2637d1491c38d1be8dfee9864 100644 (file)
--- a/level_0/f_control_group/tests/unit/c/test-control_group-copy.h
+++ b/level_0/f_control_group/tests/unit/c/test-control_group-copy.h
@@ -17,9 +17,7 @@
  *
  * @see f_control_group_copy()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_control_group_copy__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_control_group_copy__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_control_group/tests/unit/c/test-control_group.c b/level_0/f_control_group/tests/unit/c/test-control_group.c
index c295aa2dacdb53dcd7fc6ff3d71de5e9a767e06d..574f6f684ea939748de97dab724c264d8fe8a96c 100644 (file)
--- a/level_0/f_control_group/tests/unit/c/test-control_group.c
+++ b/level_0/f_control_group/tests/unit/c/test-control_group.c
@@ -20,7 +20,6 @@ int main(void) {
 
   const struct CMUnitTest tests[] = {
 
-    // f_control_group_copy() only returns memory failures.
     cmocka_unit_test(test__f_control_group_copy__works),
 
     #ifndef _di_level_0_parameter_checking_

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.c b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.c
index 7fe6b7a53393bab3f728149564444b94cab89acb..51aae96ebd74755a2c5523992959ef12b519d61b 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.c
@@ -28,16 +28,14 @@ void test__f_conversion_character_to_binary__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_character_to_binary__parameter_checking(void **state) {
+void test__f_conversion_character_to_binary__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_conversion_character_to_binary(0, 0);
+  {
+    const f_status_t status = f_conversion_character_to_binary(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_character_to_binary__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.h b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.h
index 485d090de43b62251b15c573edfa9a5a96da5f11..68b8f65c45835095617c4cd4a3b6bcc7901129d0 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_binary.h
@@ -22,9 +22,7 @@ extern void test__f_conversion_character_to_binary__fails(void **state);
  *
  * @see f_conversion_character_to_binary()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_character_to_binary__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_character_to_binary__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.c b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.c
index 6c9ee0f5c9844a43d638012ab57b74fe241cd2cd..a842adcbc5cd60f4609b0b3246df1f42d17e6a3f 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.c
@@ -36,16 +36,14 @@ void test__f_conversion_character_to_decimal__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_character_to_decimal__parameter_checking(void **state) {
+void test__f_conversion_character_to_decimal__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_conversion_character_to_decimal(0, 0);
+  {
+    const f_status_t status = f_conversion_character_to_decimal(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_character_to_decimal__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.h b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.h
index 57de4253f433aded997fcf866d72869d8fda10b0..501e8de7fc4e8ad5919bf0af7ba0a8e8435d2057 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_decimal.h
@@ -22,9 +22,7 @@ extern void test__f_conversion_character_to_decimal__fails(void **state);
  *
  * @see f_conversion_character_to_decimal()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_character_to_decimal__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_character_to_decimal__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.c b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.c
index e78a5ef54ee9a0ea4c3f07d8eeb0f23ed804cc83..a335e6676f607bf68a0be18988f65b58f8c580ed 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.c
@@ -40,16 +40,14 @@ void test__f_conversion_character_to_duodecimal__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_character_to_duodecimal__parameter_checking(void **state) {
+void test__f_conversion_character_to_duodecimal__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_conversion_character_to_duodecimal(0, 0);
+  {
+    const f_status_t status = f_conversion_character_to_duodecimal(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_character_to_duodecimal__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.h b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.h
index dc43c75ab4149feaddf3af93b33c823bdbb205ab..5d760d85bb388d09289b68266551eb95fabddb45 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_duodecimal.h
@@ -22,9 +22,7 @@ extern void test__f_conversion_character_to_duodecimal__fails(void **state);
  *
  * @see f_conversion_character_to_duodecimal()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_character_to_duodecimal__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_character_to_duodecimal__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.c b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.c
index 4e7f7d8a3eabcb76d319f6a6ca70d10b16ecb3ee..5ba8fa5bbc0e6927f2137c8a16629f5ff4ea0729 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.c
@@ -48,16 +48,14 @@ void test__f_conversion_character_to_hexidecimal__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_character_to_hexidecimal__parameter_checking(void **state) {
+void test__f_conversion_character_to_hexidecimal__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_conversion_character_to_hexidecimal(0, 0);
+  {
+    const f_status_t status = f_conversion_character_to_hexidecimal(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_character_to_hexidecimal__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.h b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.h
index 8e07d0ae1ea30e5bd61d574388581acee7f66fd8..59b4b6ccd15a73b804d55bf3b1297253136702b0 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_hexidecimal.h
@@ -22,9 +22,7 @@ extern void test__f_conversion_character_to_hexidecimal__fails(void **state);
  *
  * @see f_conversion_character_to_hexidecimal()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_character_to_hexidecimal__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_character_to_hexidecimal__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.c b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.c
index 6c9fcb4bff3bf600d68aa835388b7e3e4d73d84b..5257b7e5de80aa98c40a91879da5ecc81c008359 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.c
@@ -34,16 +34,14 @@ void test__f_conversion_character_to_octal__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_character_to_octal__parameter_checking(void **state) {
+void test__f_conversion_character_to_octal__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_conversion_character_to_octal(0, 0);
+  {
+    const f_status_t status = f_conversion_character_to_octal(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_character_to_octal__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.h b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.h
index 041b15ea661185bbd227d1439bed760e746fbaa0..c1faac4af34916b933835b5323fa236af1cde65f 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-character_to_octal.h
@@ -22,9 +22,7 @@ extern void test__f_conversion_character_to_octal__fails(void **state);
  *
  * @see f_conversion_character_to_octal()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_character_to_octal__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_character_to_octal__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.c b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.c
index e3258a8ff3126dce95663516beda49ee5e6f38e6..db89218af09e66e82a5a99737e2d55e6c0390d12 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.c
@@ -47,27 +47,25 @@ void test__f_conversion_number_signed_print__fails_for_zero(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_number_signed_print__parameter_checking(void **state) {
+void test__f_conversion_number_signed_print__parameter_checking(void **state) {
 
-    {
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
+  {
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
 
-      const f_status_t status = f_conversion_number_signed_print(0, data, 0);
+    const f_status_t status = f_conversion_number_signed_print(0, data, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      FILE *file = 0;
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
+  {
+    FILE *file = 0;
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
 
-      const f_status_t status = f_conversion_number_signed_print(0, data, file);
+    const f_status_t status = f_conversion_number_signed_print(0, data, file);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_number_signed_print__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.h b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.h
index 0c9ed827104f9ba1059ac694c6db4b8ad5f52cd9..2dacb4d5d9e77fb1a1ed479c137fced2d5a87215 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_print.h
@@ -36,9 +36,7 @@ extern void test__f_conversion_number_signed_print__fails_for_zero(void **state)
  *
  * @see f_conversion_number_signed_print()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_number_signed_print__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_number_signed_print__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.c b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.c
index 5ebdd0c1b2034f5b27d9f12d774c3538f52add33..1baf68f6820337a977e33183378b4b8a95b605e5 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.c
@@ -5,27 +5,25 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_number_signed_to_string__parameter_checking(void **state) {
+void test__f_conversion_number_signed_to_string__parameter_checking(void **state) {
 
-    {
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
+  {
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
 
-      const f_status_t status = f_conversion_number_signed_to_string(0, data, 0);
+    const f_status_t status = f_conversion_number_signed_to_string(0, data, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_string_dynamic_t string;
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
+  {
+    f_string_dynamic_t string;
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
 
-      const f_status_t status = f_conversion_number_signed_to_string(0, data, &string);
+    const f_status_t status = f_conversion_number_signed_to_string(0, data, &string);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_number_signed_to_string__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.h b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.h
index f3c9c90deee33c256158a3addc775d4caf642ae6..44a1eb71faf35686a7b2d8b5c6470ed05acfa7a6 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_signed_to_string.h
@@ -17,9 +17,7 @@
  *
  * @see f_conversion_number_signed_to_string()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_number_signed_to_string__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_number_signed_to_string__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.c b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.c
index 6d3208cb9cabe3bee312136cad4ef9180cc54dd4..a9df510058f96d83b2d666e44f5fecd8f9ef802c 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.c
@@ -47,27 +47,25 @@ void test__f_conversion_number_unsigned_print__fails_for_zero(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_number_unsigned_print__parameter_checking(void **state) {
+void test__f_conversion_number_unsigned_print__parameter_checking(void **state) {
 
-    {
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
+  {
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
 
-      const f_status_t status = f_conversion_number_unsigned_print(0, data, 0);
+    const f_status_t status = f_conversion_number_unsigned_print(0, data, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      FILE *file = 0;
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
+  {
+    FILE *file = 0;
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
 
-      const f_status_t status = f_conversion_number_unsigned_print(0, data, file);
+    const f_status_t status = f_conversion_number_unsigned_print(0, data, file);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_number_unsigned_print__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.h b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.h
index cb8e3653e5cbe112806e0ee10b2f4418f82338fc..65c6e1a97aabf9b0ec4b98015488ead179cc5805 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_print.h
@@ -36,9 +36,7 @@ extern void test__f_conversion_number_unsigned_print__fails_for_zero(void **stat
  *
  * @see f_conversion_number_unsigned_print()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_number_unsigned_print__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_number_unsigned_print__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.c b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.c
index 338a42088193a88dc9ad619abff72914d699182d..a7879fbd5c205f7b8df98256b9a4f587963f962a 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.c
@@ -5,27 +5,25 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_conversion_number_unsigned_to_string__parameter_checking(void **state) {
+void test__f_conversion_number_unsigned_to_string__parameter_checking(void **state) {
 
-    {
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
+  {
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(2, 0, 0);
 
-      const f_status_t status = f_conversion_number_unsigned_to_string(0, data, 0);
+    const f_status_t status = f_conversion_number_unsigned_to_string(0, data, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_string_dynamic_t string;
-      const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
+  {
+    f_string_dynamic_t string;
+    const f_conversion_data_t data = macro_f_conversion_data_t_initialize(1, 0, 0);
 
-      const f_status_t status = f_conversion_number_unsigned_to_string(0, data, &string);
+    const f_status_t status = f_conversion_number_unsigned_to_string(0, data, &string);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_conversion_number_unsigned_to_string__works(void **state) {
 

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.h b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.h
index 8c16f892e56c5b70cb9b069f3a88d0174d003fee..904ff84ba83b47fa069a92bc7f94986894fdffe8 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.h
+++ b/level_0/f_conversion/tests/unit/c/test-conversion-number_unsigned_to_string.h
@@ -17,9 +17,7 @@
  *
  * @see f_conversion_number_unsigned_to_string()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_conversion_number_unsigned_to_string__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_conversion_number_unsigned_to_string__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_conversion/tests/unit/c/test-conversion.c b/level_0/f_conversion/tests/unit/c/test-conversion.c
index 2528f95dd96a11099cea3c30c234ac0f9acae50b..9edfce22341e020be9d60ef9ecc91f5e56148cc6 100644 (file)
--- a/level_0/f_conversion/tests/unit/c/test-conversion.c
+++ b/level_0/f_conversion/tests/unit/c/test-conversion.c
@@ -20,19 +20,14 @@ int main(void) {
 
   const struct CMUnitTest tests[] = {
 
-    // f_conversion_character_is_binary() doesn't return failure.
     cmocka_unit_test(test__f_conversion_character_is_binary__works),
 
-    // f_conversion_character_is_decimal() doesn't return failure.
     cmocka_unit_test(test__f_conversion_character_is_decimal__works),
 
-    // f_conversion_character_is_duodecimal() doesn't return failure.
     cmocka_unit_test(test__f_conversion_character_is_duodecimal__works),
 
-    // f_conversion_character_is_hexidecimal() doesn't return failure.
     cmocka_unit_test(test__f_conversion_character_is_hexidecimal__works),
 
-    // f_conversion_character_is_octal() doesn't return failure.
     cmocka_unit_test(test__f_conversion_character_is_octal__works),
 
     cmocka_unit_test(test__f_conversion_character_to_binary__fails),
@@ -56,7 +51,6 @@ int main(void) {
     //cmocka_unit_test(test__f_conversion_number_signed_print__fails_for_zero),
     //cmocka_unit_test(test__f_conversion_number_signed_print__works),
 
-    // f_conversion_number_signed_to_string() only returns memory failures.
     cmocka_unit_test(test__f_conversion_number_signed_to_string__works),
     cmocka_unit_test(test__f_conversion_number_signed_to_string__works_for_prepend),
     cmocka_unit_test(test__f_conversion_number_signed_to_string__works_for_zero),
@@ -67,7 +61,6 @@ int main(void) {
     //cmocka_unit_test(test__f_conversion_number_unsigned_print__fails_for_zero),
     //cmocka_unit_test(test__f_conversion_number_unsigned_print__works),
 
-    // f_conversion_number_unsigned_to_string() only returns memory failures.
     cmocka_unit_test(test__f_conversion_number_unsigned_to_string__works),
     cmocka_unit_test(test__f_conversion_number_unsigned_to_string__works_for_prepend),
     cmocka_unit_test(test__f_conversion_number_unsigned_to_string__works_for_zero),

diff --git a/level_0/f_directory/tests/unit/c/test-directory-list.c b/level_0/f_directory/tests/unit/c/test-directory-list.c
index a8b7c4d2bcc7bf0d116a3fd2b20528d6d8dd269c..3f5047d3bc3662b89b7299407ad29d2127afca06 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-list.c
+++ b/level_0/f_directory/tests/unit/c/test-directory-list.c
@@ -37,18 +37,16 @@ void test__f_directory_list__fails(void **state) {
   f_string_dynamics_resize(0, &names);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_directory_list__parameter_checking(void **state) {
+void test__f_directory_list__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_directory_list(path, 0, 0, 0);
+  {
+    const f_status_t status = f_directory_list(path, 0, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_directory_list__returns_data_not(void **state) {
 

diff --git a/level_0/f_directory/tests/unit/c/test-directory-list.h b/level_0/f_directory/tests/unit/c/test-directory-list.h
index e79f07d1cfcc41600da279f80175dbdeb68d17e5..fbc08a0692e576dc81d5a725658c3ee306745be0 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-list.h
+++ b/level_0/f_directory/tests/unit/c/test-directory-list.h
@@ -22,9 +22,7 @@ extern void test__f_directory_list__fails(void **state);
  *
  * @see f_directory_list()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_directory_list__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_directory_list__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_directory/tests/unit/c/test-directory-open.c b/level_0/f_directory/tests/unit/c/test-directory-open.c
index 0fb1c0f271b60c3ab9da78029f386d8ab07ddf3b..c6d7ff4eb105f29170955144ec7054d76eef29ae 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-open.c
+++ b/level_0/f_directory/tests/unit/c/test-directory-open.c
@@ -60,18 +60,16 @@ void test__f_directory_open__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_directory_open__parameter_checking(void **state) {
+void test__f_directory_open__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_directory_open(path, 0, 0);
+  {
+    const f_status_t status = f_directory_open(path, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_directory_open__returns_data_not(void **state) {
 

diff --git a/level_0/f_directory/tests/unit/c/test-directory-open.h b/level_0/f_directory/tests/unit/c/test-directory-open.h
index d625e14f76ea308384423f38e5e997c96a29caa8..5efe2cdb28cd81875d2a25138b81093b4a0049c2 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-open.h
+++ b/level_0/f_directory/tests/unit/c/test-directory-open.h
@@ -22,9 +22,7 @@ extern void test__f_directory_open__fails(void **state);
  *
  * @see f_directory_open()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_directory_open__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_directory_open__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_directory/tests/unit/c/test-directory-open_at.c b/level_0/f_directory/tests/unit/c/test-directory-open_at.c
index bffb3b660491d144db8c4440f0dad0fab8fac639..5220794daf0f656aa44afd561ba2e94173c8c3d7 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-open_at.c
+++ b/level_0/f_directory/tests/unit/c/test-directory-open_at.c
@@ -63,18 +63,16 @@ void test__f_directory_open_at__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_directory_open_at__parameter_checking(void **state) {
+void test__f_directory_open_at__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_directory_open_at(0, path, 0, 0);
+  {
+    const f_status_t status = f_directory_open_at(0, path, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_directory_open_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_directory/tests/unit/c/test-directory-open_at.h b/level_0/f_directory/tests/unit/c/test-directory-open_at.h
index 410e749089ce1e39de4f048d2d861ac1167c884a..18b7e1a9fc9a1a9b5c6ca23f6cb6ec3b606c4a85 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-open_at.h
+++ b/level_0/f_directory/tests/unit/c/test-directory-open_at.h
@@ -22,9 +22,7 @@ extern void test__f_directory_open_at__fails(void **state);
  *
  * @see f_directory_open_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_directory_open_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_directory_open_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_directory/tests/unit/c/test-directory-remove.c b/level_0/f_directory/tests/unit/c/test-directory-remove.c
index d6511ede5b1f91803f4e11ac7ceb4787ed1ba1c1..07d81112fcf6a4be9fff4049c46e286942a17563 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-remove.c
+++ b/level_0/f_directory/tests/unit/c/test-directory-remove.c
@@ -88,18 +88,16 @@ void test__f_directory_remove__fails(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_directory_remove__parameter_checking(void **state) {
+void test__f_directory_remove__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_directory_remove(path, -1, 0);
+  {
+    const f_status_t status = f_directory_remove(path, -1, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_directory_remove__returns_data_not(void **state) {
 

diff --git a/level_0/f_directory/tests/unit/c/test-directory-remove.h b/level_0/f_directory/tests/unit/c/test-directory-remove.h
index d8dd9fa095117bb2d67b4c915c0deb87263f0a29..c8d292887f87562c769c8b7cd338af1584430357 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-remove.h
+++ b/level_0/f_directory/tests/unit/c/test-directory-remove.h
@@ -22,9 +22,7 @@ extern void test__f_directory_remove__fails(void **state);
  *
  * @see f_directory_remove()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_directory_remove__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_directory_remove__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_directory/tests/unit/c/test-directory-remove_custom.c b/level_0/f_directory/tests/unit/c/test-directory-remove_custom.c
index fd52c3e56f6ca13cf8da9e1a1233ae78d244e8ef..f7503cd3195562f092c651184dd593e711185d0f 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-remove_custom.c
+++ b/level_0/f_directory/tests/unit/c/test-directory-remove_custom.c
@@ -88,18 +88,16 @@ void test__f_directory_remove_custom__fails(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_directory_remove_custom__parameter_checking(void **state) {
+void test__f_directory_remove_custom__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_directory_remove_custom(path, -1, 0, 0);
+  {
+    const f_status_t status = f_directory_remove_custom(path, -1, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_directory_remove_custom__returns_data_not(void **state) {
 

diff --git a/level_0/f_directory/tests/unit/c/test-directory-remove_custom.h b/level_0/f_directory/tests/unit/c/test-directory-remove_custom.h
index 6ad2fc5ff39733f0ad00f655d98e6cdfb735a202..570b50cc50e81b63051338c742e74e87c4d3ea61 100644 (file)
--- a/level_0/f_directory/tests/unit/c/test-directory-remove_custom.h
+++ b/level_0/f_directory/tests/unit/c/test-directory-remove_custom.h
@@ -22,9 +22,7 @@ extern void test__f_directory_remove_custom__fails(void **state);
  *
  * @see f_directory_remove_custom()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_directory_remove_custom__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_directory_remove_custom__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_environment/tests/unit/c/test-environment-get.c b/level_0/f_environment/tests/unit/c/test-environment-get.c
index 90324ee5600384327a9159d1fb62d2263b91ad7d..f8907f89d192fccb9ed94460656fc6a5f18d7e42 100644 (file)
--- a/level_0/f_environment/tests/unit/c/test-environment-get.c
+++ b/level_0/f_environment/tests/unit/c/test-environment-get.c
@@ -22,18 +22,16 @@ void test__f_environment_get__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_environment_get__parameter_checking(void **state) {
+void test__f_environment_get__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_environment_get(path, 0);
+  {
+    const f_status_t status = f_environment_get(path, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_environment_get__returns_data_not(void **state) {
 

diff --git a/level_0/f_environment/tests/unit/c/test-environment-get.h b/level_0/f_environment/tests/unit/c/test-environment-get.h
index 32edb8edf4685455e0cf820ec628ef5ad87404fc..dbd98917e661a87556cd4995cda8c2170c3d54eb 100644 (file)
--- a/level_0/f_environment/tests/unit/c/test-environment-get.h
+++ b/level_0/f_environment/tests/unit/c/test-environment-get.h
@@ -22,9 +22,7 @@ extern void test__f_environment_get__fails(void **state);
  *
  * @see f_environment_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_environment_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_environment_get__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-close.c b/level_0/f_file/tests/unit/c/test-file-close.c
index cb3c3a2e444dd4cd971c210374b98cbe66009e80..a0a4349007c10f55a33a024d7f7d512de85924ef 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-close.c
+++ b/level_0/f_file/tests/unit/c/test-file-close.c
@@ -47,16 +47,14 @@ void test__f_file_close__fails(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_close__parameter_checking(void **state) {
+void test__f_file_close__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_close(0);
+  {
+    const f_status_t status = f_file_close(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_close__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-close.h b/level_0/f_file/tests/unit/c/test-file-close.h
index 95d7740f9c4038905a0c5bdfbb5cea56699b468e..4c0010deba16374d1948dcd616b4c70ae95d0e5a 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-close.h
+++ b/level_0/f_file/tests/unit/c/test-file-close.h
@@ -22,9 +22,7 @@ extern void test__f_file_close__fails(void **state);
  *
  * @see f_file_close()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_close__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_close__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-close_flush.c b/level_0/f_file/tests/unit/c/test-file-close_flush.c
index 0825517330b92459cfd2cfef3a5e8f2bb9961641..fc7f370beed60ae4ec156b32759edab0d6fa2b74 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-close_flush.c
+++ b/level_0/f_file/tests/unit/c/test-file-close_flush.c
@@ -50,16 +50,14 @@ void test__f_file_close_flush__fails(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_close_flush__parameter_checking(void **state) {
+void test__f_file_close_flush__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_close_flush(0);
+  {
+    const f_status_t status = f_file_close_flush(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_close_flush__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-close_flush.h b/level_0/f_file/tests/unit/c/test-file-close_flush.h
index cdcbad452be0a99c33aa8e8f2b02048dc1e31f20..09b3bfa89c9c6d32ef99780ef82b4653b7713153 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-close_flush.h
+++ b/level_0/f_file/tests/unit/c/test-file-close_flush.h
@@ -22,9 +22,7 @@ extern void test__f_file_close_flush__fails(void **state);
  *
  * @see f_file_close_flush()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_close_flush__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_close_flush__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-descriptor.c b/level_0/f_file/tests/unit/c/test-file-descriptor.c
index 3be16fe0e505ee8ccf7fb9ace5705ab8bb38abfa..ba2d6bfd4d5b74468ab4e26f6c5ff00965b94032 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-descriptor.c
+++ b/level_0/f_file/tests/unit/c/test-file-descriptor.c
@@ -18,16 +18,14 @@ void test__f_file_descriptor__fails(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_descriptor__parameter_checking(void **state) {
+void test__f_file_descriptor__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_descriptor(0);
+  {
+    const f_status_t status = f_file_descriptor(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_descriptor__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-descriptor.h b/level_0/f_file/tests/unit/c/test-file-descriptor.h
index 09e9a74de3efdd01d2b0252a1117aeb24675d4b3..5f98cf896ef341d49083189408b8a016f93112d1 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-descriptor.h
+++ b/level_0/f_file/tests/unit/c/test-file-descriptor.h
@@ -22,9 +22,7 @@ extern void test__f_file_descriptor__fails(void **state);
  *
  * @see f_file_descriptor()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_descriptor__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_descriptor__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-group_read.c b/level_0/f_file/tests/unit/c/test-file-group_read.c
index 04fdf5e6875bc963b01708c479ec4050f18ace8a..516de7cce6bcb74e07c31e4ddefa928193a36f82 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-group_read.c
+++ b/level_0/f_file/tests/unit/c/test-file-group_read.c
@@ -46,16 +46,14 @@ void test__f_file_group_read__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_group_read__parameter_checking(void **state) {
+void test__f_file_group_read__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_group_read(f_string_empty_s, F_false, 0);
+  {
+    const f_status_t status = f_file_group_read(f_string_empty_s, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_group_read__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-group_read.h b/level_0/f_file/tests/unit/c/test-file-group_read.h
index ce36ca5da72763decdd5e086f2b7b3af7aaf2c7c..30fe0346a49cd3eed703f9868562f34cce08b8b8 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-group_read.h
+++ b/level_0/f_file/tests/unit/c/test-file-group_read.h
@@ -22,9 +22,7 @@ extern void test__f_file_group_read__fails(void **state);
  *
  * @see f_file_group_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_group_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_group_read__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-link_read.c b/level_0/f_file/tests/unit/c/test-file-link_read.c
index cf7fcb871b68e38eff172cc8284c02019d782677..e2b381d1c9c6bcc8aba689de7e1bb81d16d3d044 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-link_read.c
+++ b/level_0/f_file/tests/unit/c/test-file-link_read.c
@@ -62,24 +62,22 @@ void test__f_file_link_read__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_link_read__parameter_checking(void **state) {
+void test__f_file_link_read__parameter_checking(void **state) {
 
-    struct stat statistics;
-
-    memset(&statistics, 0, sizeof(struct stat));
+  struct stat statistics;
 
-    f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
+  memset(&statistics, 0, sizeof(struct stat));
 
-    {
-      const f_status_t status = f_file_link_read(f_string_empty_s, F_true, 0);
+  f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_link_read(f_string_empty_s, F_true, 0);
 
-    f_string_dynamic_resize(0, &buffer);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_string_dynamic_resize(0, &buffer);
+}
 
 void test__f_file_link_read__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-link_read.h b/level_0/f_file/tests/unit/c/test-file-link_read.h
index f10a59a7d9a59c488c11de8ece19efb1bb12f4a7..d64c0f65079eb280b7d57905cc0a7cbe22aac7f6 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-link_read.h
+++ b/level_0/f_file/tests/unit/c/test-file-link_read.h
@@ -22,9 +22,7 @@ extern void test__f_file_link_read__fails(void **state);
  *
  * @see f_file_link_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_link_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_link_read__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-link_read_at.c b/level_0/f_file/tests/unit/c/test-file-link_read_at.c
index f163ade7a280a3d06eab25efd77fd9a92f0cd47d..52c10ac26cdd7a615d6c13244330114559171dfd 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-link_read_at.c
+++ b/level_0/f_file/tests/unit/c/test-file-link_read_at.c
@@ -62,20 +62,18 @@ void test__f_file_link_read_at__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_link_read_at__parameter_checking(void **state) {
+void test__f_file_link_read_at__parameter_checking(void **state) {
 
-    f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
-
-    {
-      const f_status_t status = f_file_link_read_at(0, f_string_empty_s, 0, 0);
+  f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_link_read_at(0, f_string_empty_s, 0, 0);
 
-    f_string_dynamic_resize(0, &buffer);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_string_dynamic_resize(0, &buffer);
+}
 
 void test__f_file_link_read_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-link_read_at.h b/level_0/f_file/tests/unit/c/test-file-link_read_at.h
index e0e6a7c7f347512da649f7cecc8749ed6db469c5..6eb069b8a2d248f417e839615890701ba3c9b1b9 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-link_read_at.h
+++ b/level_0/f_file/tests/unit/c/test-file-link_read_at.h
@@ -22,9 +22,7 @@ extern void test__f_file_link_read_at__fails(void **state);
  *
  * @see f_file_link_read_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_link_read_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_link_read_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_determine.c b/level_0/f_file/tests/unit/c/test-file-mode_determine.c
index 1e57d8214f9f16b21aabc9837af5ae498e09eb84..cc9fe403a0d4bbf852f9a7f8f12261d809ab63ce 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_determine.c
+++ b/level_0/f_file/tests/unit/c/test-file-mode_determine.c
@@ -5,19 +5,17 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_mode_determine__parameter_checking(void **state) {
+void test__f_file_mode_determine__parameter_checking(void **state) {
 
-    const mode_t mode_file = 0;
-    const f_file_mode_t mode_change = f_file_mode_t_initialize;
+  const mode_t mode_file = 0;
+  const f_file_mode_t mode_change = f_file_mode_t_initialize;
 
-    {
-      const f_status_t status = f_file_mode_determine(mode_file, mode_change, 0, F_false, 0);
+  {
+    const f_status_t status = f_file_mode_determine(mode_file, mode_change, 0, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_mode_determine__works_basic(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_determine.h b/level_0/f_file/tests/unit/c/test-file-mode_determine.h
index 2dd1def54d6fae1f1d876cfb47ea399814fe8d6f..36501cc9eb8f7111f5ec29c9313c62a2145cdfc4 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_determine.h
+++ b/level_0/f_file/tests/unit/c/test-file-mode_determine.h
@@ -15,9 +15,7 @@
  *
  * @see f_file_mode_determine()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_mode_determine__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_mode_determine__parameter_checking(void **state);
 
 /**
  * Test that function works for basic combinations.

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_from_string.c b/level_0/f_file/tests/unit/c/test-file-mode_from_string.c
index 8128f29df7ec49aa0948956fd3dab08692303dfd..0a084d1bccb3dc2df3c6dd883c73646835338c5d 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_from_string.c
+++ b/level_0/f_file/tests/unit/c/test-file-mode_from_string.c
@@ -194,32 +194,30 @@ void test__f_file_mode_from_string__fails_basic(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_mode_from_string__parameter_checking(void **state) {
+void test__f_file_mode_from_string__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_mode_from_string(f_string_empty_s, 0, 0, 0);
+  {
+    const f_status_t status = f_file_mode_from_string(f_string_empty_s, 0, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_file_mode_t mode_file = f_file_mode_t_initialize;
+  {
+    f_file_mode_t mode_file = f_file_mode_t_initialize;
 
-      const f_status_t status = f_file_mode_from_string(f_string_empty_s, 0, &mode_file, 0);
+    const f_status_t status = f_file_mode_from_string(f_string_empty_s, 0, &mode_file, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      uint8_t replace = 0;
+  {
+    uint8_t replace = 0;
 
-      const f_status_t status = f_file_mode_from_string(f_string_empty_s, 0, 0, &replace);
+    const f_status_t status = f_file_mode_from_string(f_string_empty_s, 0, 0, &replace);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_mode_from_string__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_from_string.h b/level_0/f_file/tests/unit/c/test-file-mode_from_string.h
index a0a267f260f4c8ef5ae20d6f3c21b965428a4ba1..1a0a9e574b204b0ee945db9201c422ae8f149977 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_from_string.h
+++ b/level_0/f_file/tests/unit/c/test-file-mode_from_string.h
@@ -22,9 +22,7 @@ extern void test__f_file_mode_from_string__fails_basic(void **state);
  *
  * @see f_file_mode_from_string()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_mode_from_string__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_mode_from_string__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_read.c b/level_0/f_file/tests/unit/c/test-file-mode_read.c
index 4380f5f1fff8aea91b61ea841e7616f9290bb74a..ec3872ee87f5be756483b19b95ec910d11f7f663 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_read.c
+++ b/level_0/f_file/tests/unit/c/test-file-mode_read.c
@@ -48,16 +48,14 @@ void test__f_file_mode_read__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_mode_read__parameter_checking(void **state) {
+void test__f_file_mode_read__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_mode_read(f_string_empty_s, F_true, 0);
+  {
+    const f_status_t status = f_file_mode_read(f_string_empty_s, F_true, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_mode_read__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_read.h b/level_0/f_file/tests/unit/c/test-file-mode_read.h
index 0052f1798cd1724b9d13fd2d7e563569dc4aeb44..4a6fe4186fe1bcd34d326fdb8f2d2d0b6a48ac0f 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_read.h
+++ b/level_0/f_file/tests/unit/c/test-file-mode_read.h
@@ -22,9 +22,7 @@ extern void test__f_file_mode_read__fails(void **state);
  *
  * @see f_file_mode_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_mode_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_mode_read__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_read_at.c b/level_0/f_file/tests/unit/c/test-file-mode_read_at.c
index f726ec9bc41279035a0c1db7e0e48757b384b165..0b91df0142f9d6b68b0bbab7d3b5cb5891be4099 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_read_at.c
+++ b/level_0/f_file/tests/unit/c/test-file-mode_read_at.c
@@ -48,16 +48,14 @@ void test__f_file_mode_read_at__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_mode_read_at__parameter_checking(void **state) {
+void test__f_file_mode_read_at__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_mode_read_at(0, f_string_empty_s, 0, 0);
+  {
+    const f_status_t status = f_file_mode_read_at(0, f_string_empty_s, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_mode_read_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_read_at.h b/level_0/f_file/tests/unit/c/test-file-mode_read_at.h
index 647003d9048f45bf4371830e6e1961472a35dade..f8c9c1dca43c7c014a4f8109932e218ebf252cee 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_read_at.h
+++ b/level_0/f_file/tests/unit/c/test-file-mode_read_at.h
@@ -22,9 +22,7 @@ extern void test__f_file_mode_read_at__fails(void **state);
  *
  * @see f_file_mode_read_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_mode_read_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_mode_read_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_to_mode.c b/level_0/f_file/tests/unit/c/test-file-mode_to_mode.c
index 88d5526ba114469edcd574eafb479c079b7770c0..2804400bdd0c897819efda8f5632f46c84d8e70d 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_to_mode.c
+++ b/level_0/f_file/tests/unit/c/test-file-mode_to_mode.c
@@ -5,18 +5,16 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_mode_to_mode__parameter_checking(void **state) {
+void test__f_file_mode_to_mode__parameter_checking(void **state) {
 
-    const f_file_mode_t mode = f_file_mode_t_initialize;
+  const f_file_mode_t mode = f_file_mode_t_initialize;
 
-    {
-      const f_status_t status = f_file_mode_to_mode(mode, 0);
+  {
+    const f_status_t status = f_file_mode_to_mode(mode, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_mode_to_mode__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-mode_to_mode.h b/level_0/f_file/tests/unit/c/test-file-mode_to_mode.h
index 31ca2e386ec55c95fa2ad3a533fb57e759320be6..025c8cfc6465cf612ffa0caef88ddfe2891243e1 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-mode_to_mode.h
+++ b/level_0/f_file/tests/unit/c/test-file-mode_to_mode.h
@@ -15,9 +15,7 @@
  *
  * @see f_file_mode_to_mode()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_mode_to_mode__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_mode_to_mode__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-name_base.c b/level_0/f_file/tests/unit/c/test-file-name_base.c
index a8f0726e109be3fa1ee1d0fc9b046bb98a18e96d..024f7d2e08e444a85db135eeb611a4af7573757d 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-name_base.c
+++ b/level_0/f_file/tests/unit/c/test-file-name_base.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_name_base__parameter_checking(void **state) {
+void test__f_file_name_base__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_name_base(f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_name_base(f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_name_base__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-name_base.h b/level_0/f_file/tests/unit/c/test-file-name_base.h
index a10492a44ccaabc3f9b7ed2c76298dbbb441fcc5..5ca33595d4d4c344425a152cc26b59f79ca88eb6 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-name_base.h
+++ b/level_0/f_file/tests/unit/c/test-file-name_base.h
@@ -15,9 +15,7 @@
  *
  * @see f_file_name_base()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_name_base__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_name_base__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-name_directory.c b/level_0/f_file/tests/unit/c/test-file-name_directory.c
index 6fdc8a43e75a20ee6f2d942283c19de01abc7e3b..78a7f2080289d635b72e07084ce8a931fbe1c254 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-name_directory.c
+++ b/level_0/f_file/tests/unit/c/test-file-name_directory.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_name_directory__parameter_checking(void **state) {
+void test__f_file_name_directory__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_name_directory(f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_name_directory(f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_name_directory__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-name_directory.h b/level_0/f_file/tests/unit/c/test-file-name_directory.h
index d540b309abe3781889ce3cf6b6af4a4b7cb28794..52bd56b0edd674cb14a8c81f5e54aa882b5fb1ad 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-name_directory.h
+++ b/level_0/f_file/tests/unit/c/test-file-name_directory.h
@@ -15,9 +15,7 @@
  *
  * @see f_file_name_directory()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_name_directory__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_name_directory__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-open.c b/level_0/f_file/tests/unit/c/test-file-open.c
index 5cbb4c579547161bbaafb478e3e35c9b0179ad09..c31d3c9f46633c16676079432b7f748113f323c7 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-open.c
+++ b/level_0/f_file/tests/unit/c/test-file-open.c
@@ -70,18 +70,16 @@ void test__f_file_open__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_open__parameter_checking(void **state) {
+void test__f_file_open__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_file_open(path, 0, 0);
+  {
+    const f_status_t status = f_file_open(path, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_open__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-open.h b/level_0/f_file/tests/unit/c/test-file-open.h
index 66fa65af9a9c6612638b93c7ee694a5116c59270..403abdcd23e81be69773cb2760ffea943a13b215 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-open.h
+++ b/level_0/f_file/tests/unit/c/test-file-open.h
@@ -22,9 +22,7 @@ extern void test__f_file_open__fails(void **state);
  *
  * @see f_file_open()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_open__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_open__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-open_at.c b/level_0/f_file/tests/unit/c/test-file-open_at.c
index 6f406ec6751fb520d297eb0fa7ed5f53af8a8bea..7f2df1a4835e19698b9c424749a377f27a7cbbbb 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-open_at.c
+++ b/level_0/f_file/tests/unit/c/test-file-open_at.c
@@ -72,16 +72,14 @@ void test__f_file_open_at__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_open_at__parameter_checking(void **state) {
+void test__f_file_open_at__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_open_at(0, f_string_empty_s, 0, 0);
+  {
+    const f_status_t status = f_file_open_at(0, f_string_empty_s, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_open_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-open_at.h b/level_0/f_file/tests/unit/c/test-file-open_at.h
index 231b8ba7a897665a33f6e15c1c9bbc0ae400a7d8..0d75869cd90c6fae141141ab3d019369bf83c882 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-open_at.h
+++ b/level_0/f_file/tests/unit/c/test-file-open_at.h
@@ -22,9 +22,7 @@ extern void test__f_file_open_at__fails(void **state);
  *
  * @see f_file_open_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_open_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_open_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-owner_read.c b/level_0/f_file/tests/unit/c/test-file-owner_read.c
index ac7e6419a5c161e3c1f21c9d1d6d635b543d6081..a42df6a010a86381ed7d6593426a804b804d7d54 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-owner_read.c
+++ b/level_0/f_file/tests/unit/c/test-file-owner_read.c
@@ -46,16 +46,14 @@ void test__f_file_owner_read__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_owner_read__parameter_checking(void **state) {
+void test__f_file_owner_read__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_owner_read(f_string_empty_s, F_false, 0);
+  {
+    const f_status_t status = f_file_owner_read(f_string_empty_s, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_owner_read__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-owner_read.h b/level_0/f_file/tests/unit/c/test-file-owner_read.h
index da3a849c536bf0121709765376f0a5b3b15fffff..6aa68a23bd4a12bbca9d9b38a387b9748b2096c0 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-owner_read.h
+++ b/level_0/f_file/tests/unit/c/test-file-owner_read.h
@@ -22,9 +22,7 @@ extern void test__f_file_owner_read__fails(void **state);
  *
  * @see f_file_owner_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_owner_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_owner_read__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-read.c b/level_0/f_file/tests/unit/c/test-file-read.c
index 92234227a4d22eb11bb9407ac34372893269f0eb..2ccfc15eebc967fc7e2659423cb51f5bc6ec05de 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-read.c
+++ b/level_0/f_file/tests/unit/c/test-file-read.c
@@ -49,39 +49,37 @@ void test__f_file_read__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_read__parameter_checking(void **state) {
+void test__f_file_read__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
-
-    file.id = 1;
+  f_file_t file = f_file_t_initialize;
+  f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
 
-    {
-      const f_status_t status = f_file_read(file, 0);
+  file.id = 1;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_read(file, 0);
 
-    file.size_read = 0;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_file_read(file, 0);
+  file.size_read = 0;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_read(file, 0);
 
-    {
-      f_string_dynamic_t string = f_string_dynamic_t_initialize;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-      const f_status_t status = f_file_read(file, &string);
+  {
+    f_string_dynamic_t string = f_string_dynamic_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    const f_status_t status = f_file_read(file, &string);
 
-    f_string_dynamic_resize(0, &buffer);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_string_dynamic_resize(0, &buffer);
+}
 
 void test__f_file_read__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-read.h b/level_0/f_file/tests/unit/c/test-file-read.h
index e6b89d9e57616b4e07e071620db7ac78d105d2d4..8611710aa1180596d18b4b1c94e722e3dbe222d3 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-read.h
+++ b/level_0/f_file/tests/unit/c/test-file-read.h
@@ -22,9 +22,7 @@ extern void test__f_file_read__fails(void **state);
  *
  * @see f_file_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_read__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-read_block.c b/level_0/f_file/tests/unit/c/test-file-read_block.c
index 8e6b0fa034424e4b6c9f2092c5ab1359c3ef4310..8b546b6a5b11c70eab0a0c51dfddedb5dbf67b4e 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-read_block.c
+++ b/level_0/f_file/tests/unit/c/test-file-read_block.c
@@ -49,39 +49,37 @@ void test__f_file_read_block__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_read_block__parameter_checking(void **state) {
+void test__f_file_read_block__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
-
-    file.id = 1;
+  f_file_t file = f_file_t_initialize;
+  f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
 
-    {
-      const f_status_t status = f_file_read_block(file, 0);
+  file.id = 1;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_read_block(file, 0);
 
-    file.size_read = 0;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_file_read_block(file, 0);
+  file.size_read = 0;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_read_block(file, 0);
 
-    {
-      f_string_dynamic_t string = f_string_dynamic_t_initialize;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-      const f_status_t status = f_file_read_block(file, &string);
+  {
+    f_string_dynamic_t string = f_string_dynamic_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    const f_status_t status = f_file_read_block(file, &string);
 
-    f_string_dynamic_resize(0, &buffer);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_string_dynamic_resize(0, &buffer);
+}
 
 void test__f_file_read_block__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-read_block.h b/level_0/f_file/tests/unit/c/test-file-read_block.h
index dfc11e50810f083e76777e9153ff8c3b17180113..d3621b5dc0ae58f0142833e5b305acce06a4e084 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-read_block.h
+++ b/level_0/f_file/tests/unit/c/test-file-read_block.h
@@ -22,9 +22,7 @@ extern void test__f_file_read_block__fails(void **state);
  *
  * @see f_file_read_block()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_read_block__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_read_block__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-read_until.c b/level_0/f_file/tests/unit/c/test-file-read_until.c
index 3e44aa6b506f2a220878ab3fb5fe18580dc57b57..a3fd48e189bf1e86a9c8090f763296cdb46bb8dc 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-read_until.c
+++ b/level_0/f_file/tests/unit/c/test-file-read_until.c
@@ -49,39 +49,37 @@ void test__f_file_read_until__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_read_until__parameter_checking(void **state) {
+void test__f_file_read_until__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
-
-    file.id = 1;
+  f_file_t file = f_file_t_initialize;
+  f_string_dynamic_t buffer = f_string_dynamic_t_initialize;
 
-    {
-      const f_status_t status = f_file_read_until(file, 1, 0);
+  file.id = 1;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_read_until(file, 1, 0);
 
-    file.size_read = 0;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_file_read_until(file, 1, 0);
+  file.size_read = 0;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+  {
+    const f_status_t status = f_file_read_until(file, 1, 0);
 
-    {
-      f_string_dynamic_t string = f_string_dynamic_t_initialize;
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-      const f_status_t status = f_file_read_until(file, 1, &string);
+  {
+    f_string_dynamic_t string = f_string_dynamic_t_initialize;
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    const f_status_t status = f_file_read_until(file, 1, &string);
 
-    f_string_dynamic_resize(0, &buffer);
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+
+  f_string_dynamic_resize(0, &buffer);
+}
 
 void test__f_file_read_until__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-read_until.h b/level_0/f_file/tests/unit/c/test-file-read_until.h
index 88de066af0947393e828105170549583016d589e..c6f1513e610bb7da89bb6650cdace5a770dc1a89 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-read_until.h
+++ b/level_0/f_file/tests/unit/c/test-file-read_until.h
@@ -22,9 +22,7 @@ extern void test__f_file_read_until__fails(void **state);
  *
  * @see f_file_read_until()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_read_until__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_read_until__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-seek.c b/level_0/f_file/tests/unit/c/test-file-seek.c
index 8f03596800986d05a77f7571d866a3bccb1b52c4..5ce244aacbe3ad55f2f186690da2f3aa7f065b07 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-seek.c
+++ b/level_0/f_file/tests/unit/c/test-file-seek.c
@@ -38,30 +38,28 @@ void test__f_file_seek__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_seek__parameter_checking(void **state) {
+void test__f_file_seek__parameter_checking(void **state) {
 
-    off_t seeked = 0;
+  off_t seeked = 0;
 
-    {
-      const f_status_t status = f_file_seek(0, -1, 0, 0);
+  {
+    const f_status_t status = f_file_seek(0, -1, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_file_seek(0, -1, 0, &seeked);
+  {
+    const f_status_t status = f_file_seek(0, -1, 0, &seeked);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_file_seek(0, 0, 0, 0);
+  {
+    const f_status_t status = f_file_seek(0, 0, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_seek__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-seek.h b/level_0/f_file/tests/unit/c/test-file-seek.h
index 32938d5c93dda08268ba0c0a84b6bfe5dcaa6004..776ea2128ecc380e24f42970bcfa65054c4f4829 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-seek.h
+++ b/level_0/f_file/tests/unit/c/test-file-seek.h
@@ -22,9 +22,7 @@ extern void test__f_file_seek__fails(void **state);
  *
  * @see f_file_seek()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_seek__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_seek__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-size.c b/level_0/f_file/tests/unit/c/test-file-size.c
index ee07e1e0195c01de3c56b7b187f5989c97d91ed4..1dfcf90a1ad4d3bd9c28f48c5d702db26a5d9225 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-size.c
+++ b/level_0/f_file/tests/unit/c/test-file-size.c
@@ -48,16 +48,14 @@ void test__f_file_size__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_size__parameter_checking(void **state) {
+void test__f_file_size__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_size(f_string_empty_s, F_false, 0);
+  {
+    const f_status_t status = f_file_size(f_string_empty_s, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_size__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-size.h b/level_0/f_file/tests/unit/c/test-file-size.h
index a753a4f4ca59170890f2c1ebc44caf50b9d31b93..d92c91cb3cb14649ecd7f093c3eed8f628450a00 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-size.h
+++ b/level_0/f_file/tests/unit/c/test-file-size.h
@@ -22,9 +22,7 @@ extern void test__f_file_size__fails(void **state);
  *
  * @see f_file_size()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_size__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_size__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-size_at.c b/level_0/f_file/tests/unit/c/test-file-size_at.c
index b5559de2b246347fd8772c1850f0565a067235c1..c402e4c16ce879521d8ea30cd8c81f4d24aa6bc4 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-size_at.c
+++ b/level_0/f_file/tests/unit/c/test-file-size_at.c
@@ -50,16 +50,14 @@ void test__f_file_size_at__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_size_at__parameter_checking(void **state) {
+void test__f_file_size_at__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_size_at(0, f_string_empty_s, F_false, 0);
+  {
+    const f_status_t status = f_file_size_at(0, f_string_empty_s, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_size_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-size_at.h b/level_0/f_file/tests/unit/c/test-file-size_at.h
index 83b5314c634b9ba44126909dbe6c0e02b6af0913..dcc977c91c00229e653b0c72659073a47a3041fc 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-size_at.h
+++ b/level_0/f_file/tests/unit/c/test-file-size_at.h
@@ -22,9 +22,7 @@ extern void test__f_file_size_at__fails(void **state);
  *
  * @see f_file_size_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_size_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_size_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-size_by_id.c b/level_0/f_file/tests/unit/c/test-file-size_by_id.c
index 8bf580f451f124fe82c8c2d5ad76a09f26d947ca..ceb8f20ab304ff3ed7bf1ba48ca5b6a41ae2b451 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-size_by_id.c
+++ b/level_0/f_file/tests/unit/c/test-file-size_by_id.c
@@ -48,16 +48,14 @@ void test__f_file_size_by_id__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_size_by_id__parameter_checking(void **state) {
+void test__f_file_size_by_id__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_size_by_id(0, 0);
+  {
+    const f_status_t status = f_file_size_by_id(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_size_by_id__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-size_by_id.h b/level_0/f_file/tests/unit/c/test-file-size_by_id.h
index 088faa664ae7a2a368b75e50149a022d22610712..095e598e203377c805183ae31b2f4f0926cd2325 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-size_by_id.h
+++ b/level_0/f_file/tests/unit/c/test-file-size_by_id.h
@@ -22,9 +22,7 @@ extern void test__f_file_size_by_id__fails(void **state);
  *
  * @see f_file_size_by_id()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_size_by_id__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_size_by_id__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stat.c b/level_0/f_file/tests/unit/c/test-file-stat.c
index 29dca5c6ae105761642eceb6ccba12f79f78f550..264985d94df808d3b153924def911f770f89c62f 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stat.c
+++ b/level_0/f_file/tests/unit/c/test-file-stat.c
@@ -50,16 +50,14 @@ void test__f_file_stat__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stat__parameter_checking(void **state) {
+void test__f_file_stat__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stat(f_string_empty_s, F_false, 0);
+  {
+    const f_status_t status = f_file_stat(f_string_empty_s, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stat__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stat.h b/level_0/f_file/tests/unit/c/test-file-stat.h
index ddb361c9581d09b7de564cd8a780387767a6869a..edc7780b885672a71cfcb2a4cbfc0e2ab7a68695 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stat.h
+++ b/level_0/f_file/tests/unit/c/test-file-stat.h
@@ -22,9 +22,7 @@ extern void test__f_file_stat__fails(void **state);
  *
  * @see f_file_stat()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stat__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stat__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-stat_at.c b/level_0/f_file/tests/unit/c/test-file-stat_at.c
index 4d9aee0375c9c99cb8e3fcb4296cefa7eec3c73a..284ff71798afa4b869d648061aed0efdcc2e8c09 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stat_at.c
+++ b/level_0/f_file/tests/unit/c/test-file-stat_at.c
@@ -52,16 +52,14 @@ void test__f_file_stat_at__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stat_at__parameter_checking(void **state) {
+void test__f_file_stat_at__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stat_at(0, f_string_empty_s, F_false, 0);
+  {
+    const f_status_t status = f_file_stat_at(0, f_string_empty_s, F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stat_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stat_at.h b/level_0/f_file/tests/unit/c/test-file-stat_at.h
index 733aebe44acb661cc4dc5e93ba4bfa9b6e947627..5382460bacf6703555072aeb858f1e056976dc1b 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stat_at.h
+++ b/level_0/f_file/tests/unit/c/test-file-stat_at.h
@@ -22,9 +22,7 @@ extern void test__f_file_stat_at__fails(void **state);
  *
  * @see f_file_stat_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stat_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stat_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-stat_by_id.c b/level_0/f_file/tests/unit/c/test-file-stat_by_id.c
index ba220eff8a49440acbd8a9468551b18f20fb7e5e..7282fa0e7cd127e6d95c3e550d0e5d8886099352 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stat_by_id.c
+++ b/level_0/f_file/tests/unit/c/test-file-stat_by_id.c
@@ -50,16 +50,14 @@ void test__f_file_stat_by_id__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stat_by_id__parameter_checking(void **state) {
+void test__f_file_stat_by_id__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stat_by_id(0, 0);
+  {
+    const f_status_t status = f_file_stat_by_id(0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stat_by_id__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stat_by_id.h b/level_0/f_file/tests/unit/c/test-file-stat_by_id.h
index 2565d2651cc2a84728e4922aff8d64bbea39ae33..bb47bea9e6c631042fe1be2cab9e70bc7622e4b1 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stat_by_id.h
+++ b/level_0/f_file/tests/unit/c/test-file-stat_by_id.h
@@ -22,9 +22,7 @@ extern void test__f_file_stat_by_id__fails(void **state);
  *
  * @see f_file_stat_by_id()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stat_by_id__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stat_by_id__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_close.c b/level_0/f_file/tests/unit/c/test-file-stream_close.c
index 3c42a81f959586a1b6c6daa047350b167115f8c9..26404fc672e9a9aca12ae7ca99949ba885ad9bbc 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_close.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_close.c
@@ -151,16 +151,14 @@ void test__f_file_stream_close__fails_for_stream(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_close__parameter_checking(void **state) {
+void test__f_file_stream_close__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stream_close(F_false, 0);
+  {
+    const f_status_t status = f_file_stream_close(F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_close__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_close.h b/level_0/f_file/tests/unit/c/test-file-stream_close.h
index 5eeffc0402d41090ae43e60353a9ae386c1f4fe7..978dff7e5268d8d970d00d6b44dd9dadf37a6971 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_close.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_close.h
@@ -29,9 +29,7 @@ extern void test__f_file_stream_close__fails_for_stream(void **state);
  *
  * @see f_file_stream_close()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_close__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_close__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_open.c b/level_0/f_file/tests/unit/c/test-file-stream_open.c
index 38726c835d89c3eca5de4e52e0c903bb16482924..aa3aa29c653c913e88959d21f214e87ed9255aa2 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_open.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_open.c
@@ -82,16 +82,14 @@ void test__f_file_stream_open__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_open__parameter_checking(void **state) {
+void test__f_file_stream_open__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stream_open(f_string_empty_s, f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_stream_open(f_string_empty_s, f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_open__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_open.h b/level_0/f_file/tests/unit/c/test-file-stream_open.h
index 21772b4c69ab8aefd86e6291b97e9a7d762247f0..657cc9391f55009f23ea84e96438b727fb5f3339 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_open.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_open.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_open__fails(void **state);
  *
  * @see f_file_stream_open()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_open__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_open__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.c b/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.c
index 317ac8e19633388d79199d5e1eea8602bd81bd4a..db29ca5939726c1ce2137f883d4f7a0c4e34b068 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.c
@@ -80,16 +80,14 @@ void test__f_file_stream_open_descriptor__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_open_descriptor__parameter_checking(void **state) {
+void test__f_file_stream_open_descriptor__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stream_open_descriptor(f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_stream_open_descriptor(f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_open_descriptor__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.h b/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.h
index a2deb6d2a4d6132430cec6037f979bf71c714a6a..677d72930fd8169627232c5ff91d158d47a0c2f9 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_open_descriptor.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_open_descriptor__fails(void **state);
  *
  * @see f_file_stream_open_descriptor()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_open_descriptor__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_open_descriptor__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_read.c b/level_0/f_file/tests/unit/c/test-file-stream_read.c
index fcdf1a785e35b705f30eaabfb955cc04cd8f15b3..95ca8545db7f02e30495177198f7cc3437cd2688 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_read.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_read.c
@@ -59,34 +59,32 @@ void test__f_file_stream_read__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_read__parameter_checking(void **state) {
+void test__f_file_stream_read__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
+  f_file_t file = f_file_t_initialize;
 
-    {
-      const f_status_t status = f_file_stream_read(file, 0);
+  {
+    const f_status_t status = f_file_stream_read(file, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    file.size_read = 0;
+  file.size_read = 0;
 
-    {
-      const f_status_t status = f_file_stream_read(file, 0);
+  {
+    const f_status_t status = f_file_stream_read(file, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_string_dynamic_t string = f_string_dynamic_t_initialize;
+  {
+    f_string_dynamic_t string = f_string_dynamic_t_initialize;
 
-      const f_status_t status = f_file_stream_read(file, &string);
+    const f_status_t status = f_file_stream_read(file, &string);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_read__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_read.h b/level_0/f_file/tests/unit/c/test-file-stream_read.h
index 5c88393b8c59e3c3e97cf6702505bc5ebec22b3b..72b98b1ee9a04499ef4f96382f2c905f5cf70d7a 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_read.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_read.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_read__fails(void **state);
  *
  * @see f_file_stream_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_read__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_read_block.c b/level_0/f_file/tests/unit/c/test-file-stream_read_block.c
index 2f0f122c7e8430101d8251c919bad3ca0f9d586c..fec3f97eb3d11591867b3624168679132ca61dfe 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_read_block.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_read_block.c
@@ -59,34 +59,32 @@ void test__f_file_stream_read_block__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_read_block__parameter_checking(void **state) {
+void test__f_file_stream_read_block__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
+  f_file_t file = f_file_t_initialize;
 
-    {
-      const f_status_t status = f_file_stream_read_block(file, 0);
+  {
+    const f_status_t status = f_file_stream_read_block(file, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    file.size_read = 0;
+  file.size_read = 0;
 
-    {
-      const f_status_t status = f_file_stream_read_block(file, 0);
+  {
+    const f_status_t status = f_file_stream_read_block(file, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_string_dynamic_t string = f_string_dynamic_t_initialize;
+  {
+    f_string_dynamic_t string = f_string_dynamic_t_initialize;
 
-      const f_status_t status = f_file_stream_read_block(file, &string);
+    const f_status_t status = f_file_stream_read_block(file, &string);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_read_block__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_read_block.h b/level_0/f_file/tests/unit/c/test-file-stream_read_block.h
index aeea39f0e17bb7baecc24780e2658e9417750056..7e8960d02b860938a7eef6a1d8dedeba7f80314d 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_read_block.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_read_block.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_read_block__fails(void **state);
  *
  * @see f_file_stream_read_block()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_read_block__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_read_block__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_read_until.c b/level_0/f_file/tests/unit/c/test-file-stream_read_until.c
index c8a408c5f4e663f23a567fdd303175732dabd183..c7578b48ae3b5e32cf2cda2e9acb6b9a172e3c6b 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_read_until.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_read_until.c
@@ -59,34 +59,32 @@ void test__f_file_stream_read_until__fails(void **state) {
   f_string_dynamic_resize(0, &buffer);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_read_until__parameter_checking(void **state) {
+void test__f_file_stream_read_until__parameter_checking(void **state) {
 
   f_file_t file = f_file_t_initialize;
 
-    {
-      const f_status_t status = f_file_stream_read_until(file, 0, 0);
+  {
+    const f_status_t status = f_file_stream_read_until(file, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    file.size_read = 0;
+  file.size_read = 0;
 
-    {
-      const f_status_t status = f_file_stream_read_until(file, 0, 0);
+  {
+    const f_status_t status = f_file_stream_read_until(file, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_string_dynamic_t string = f_string_dynamic_t_initialize;
+  {
+    f_string_dynamic_t string = f_string_dynamic_t_initialize;
 
-      const f_status_t status = f_file_stream_read_until(file, 0, &string);
+    const f_status_t status = f_file_stream_read_until(file, 0, &string);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_read_until__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_read_until.h b/level_0/f_file/tests/unit/c/test-file-stream_read_until.h
index c7d811f9e972a4794d096e92b2129f9964dd5342..4bc01ea65fe2ca4a51485e0a78aad0e266fdcd17 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_read_until.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_read_until.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_read_until__fails(void **state);
  *
  * @see f_file_stream_read_until()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_read_until__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_read_until__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_reopen.c b/level_0/f_file/tests/unit/c/test-file-stream_reopen.c
index a208463d755ba5f565328c11f580a071c7b9a877..e0645fc28b2d55aafa09bd043c96782fb60a1a4f 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_reopen.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_reopen.c
@@ -78,16 +78,14 @@ void test__f_file_stream_reopen__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_reopen__parameter_checking(void **state) {
+void test__f_file_stream_reopen__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_stream_reopen(f_string_empty_s, f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_stream_reopen(f_string_empty_s, f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_reopen__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_reopen.h b/level_0/f_file/tests/unit/c/test-file-stream_reopen.h
index abd57680ea4dd93d410e4333c6e9db1ca523d2ad..3422ad8e538cf5fe399e090e5fc5d639aea39db9 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_reopen.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_reopen.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_reopen__fails(void **state);
  *
  * @see f_file_stream_reopen()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_reopen__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_reopen__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write.c b/level_0/f_file/tests/unit/c/test-file-stream_write.c
index 7af121d6a534e7750782a838cbcef7d7bbb9fc4a..683e1ecf6650471a30555da182a96234827b8f8f 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write.c
@@ -51,19 +51,17 @@ void test__f_file_stream_write__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_write__parameter_checking(void **state) {
+void test__f_file_stream_write__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    {
-      const f_status_t status = f_file_stream_write(file, f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_stream_write(file, f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_write__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write.h b/level_0/f_file/tests/unit/c/test-file-stream_write.h
index d28a9411c552691245f8262af3a511396d8989ee..839b25952afc1be0632e6e6d15f6bde8e196cac2 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_write__fails(void **state);
  *
  * @see f_file_stream_write()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_write__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_write__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write_block.c b/level_0/f_file/tests/unit/c/test-file-stream_write_block.c
index 40e9d1a4dd3f729d22effca8579d810f3f8259fd..3716b3548d1b18bff27a67ed73944f108d6e2c8c 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write_block.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write_block.c
@@ -51,19 +51,17 @@ void test__f_file_stream_write_block__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_write_block__parameter_checking(void **state) {
+void test__f_file_stream_write_block__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    {
-      const f_status_t status = f_file_stream_write_block(file, f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_stream_write_block(file, f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_write_block__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write_block.h b/level_0/f_file/tests/unit/c/test-file-stream_write_block.h
index 0125d97d2df1d885ae90d7826e7c0c29e7c8cb5c..61e9671767e51004b5a7f1df1049e71a02fb6eb8 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write_block.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write_block.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_write_block__fails(void **state);
  *
  * @see f_file_stream_write_block()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_write_block__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_write_block__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write_range.c b/level_0/f_file/tests/unit/c/test-file-stream_write_range.c
index 34cbb22ea3574968c51ddbf26ead84dfcb46e09c..c00e90d5562dda94e31d3fdf7366b960c0468a6f 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write_range.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write_range.c
@@ -52,21 +52,19 @@ void test__f_file_stream_write_range__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_write_range__parameter_checking(void **state) {
+void test__f_file_stream_write_range__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    const f_string_range_t range = f_string_range_t_initialize;
+  const f_string_range_t range = f_string_range_t_initialize;
 
-    {
-      const f_status_t status = f_file_stream_write_range(file, f_string_empty_s, range, 0);
+  {
+    const f_status_t status = f_file_stream_write_range(file, f_string_empty_s, range, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_write_range__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write_range.h b/level_0/f_file/tests/unit/c/test-file-stream_write_range.h
index ac9d392b74500317006384c20e8df1bae50b9dc6..49eadff7cb80060ffc1be7939e16f9bc4bbdc39f 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write_range.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write_range.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_write_range__fails(void **state);
  *
  * @see f_file_stream_write_range()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_write_range__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_write_range__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write_until.c b/level_0/f_file/tests/unit/c/test-file-stream_write_until.c
index fba5f52e5bd3bf1d0144bba5dedea97c8b72a56f..fb882b95f8b3c8679cd73050f2373b0e36c3c6f8 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write_until.c
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write_until.c
@@ -51,19 +51,17 @@ void test__f_file_stream_write_until__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_stream_write_until__parameter_checking(void **state) {
+void test__f_file_stream_write_until__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    {
-      const f_status_t status = f_file_stream_write_until(file, f_string_empty_s, 0, 0);
+  {
+    const f_status_t status = f_file_stream_write_until(file, f_string_empty_s, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_stream_write_until__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-stream_write_until.h b/level_0/f_file/tests/unit/c/test-file-stream_write_until.h
index 48b909292e2a7473d24b85f8eefe14d060f7806d..dc30e050d1356c7aa1fe9eec435dbe482b788fe7 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-stream_write_until.h
+++ b/level_0/f_file/tests/unit/c/test-file-stream_write_until.h
@@ -22,9 +22,7 @@ extern void test__f_file_stream_write_until__fails(void **state);
  *
  * @see f_file_stream_write_until()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_stream_write_until__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_stream_write_until__parameter_checking(void **state);
 
 /**
  * Test that function works but the file stream is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-type.c b/level_0/f_file/tests/unit/c/test-file-type.c
index a35807ed1177588e6070ba56cc3c218dfd2d089f..8f415eab304eaa9143b513b7cdce699109f239ae 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-type.c
+++ b/level_0/f_file/tests/unit/c/test-file-type.c
@@ -48,16 +48,14 @@ void test__f_file_type__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_type__parameter_checking(void **state) {
+void test__f_file_type__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_type(f_string_empty_s, F_true, 0);
+  {
+    const f_status_t status = f_file_type(f_string_empty_s, F_true, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_type__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-type.h b/level_0/f_file/tests/unit/c/test-file-type.h
index da8004d8d1e40cbe5503fb50232239e031cf42bd..7b79d0831700e42dda9160a1470c8a9902eccd12 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-type.h
+++ b/level_0/f_file/tests/unit/c/test-file-type.h
@@ -22,9 +22,7 @@ extern void test__f_file_type__fails(void **state);
  *
  * @see f_file_type()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_type__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_type__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-type_at.c b/level_0/f_file/tests/unit/c/test-file-type_at.c
index 229f63a7a02c1d4f0ef9f0dd3ef221f3a87884b2..92d11a064065b2a2e6fc1f603b32cafb394eef6a 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-type_at.c
+++ b/level_0/f_file/tests/unit/c/test-file-type_at.c
@@ -48,16 +48,14 @@ void test__f_file_type_at__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_type_at__parameter_checking(void **state) {
+void test__f_file_type_at__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_type_at(0, f_string_empty_s, 0, 0);
+  {
+    const f_status_t status = f_file_type_at(0, f_string_empty_s, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_type_at__returns_data_not(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-type_at.h b/level_0/f_file/tests/unit/c/test-file-type_at.h
index 69b0dc5e08800a9f221b135328486d5654f082f8..ea11010b9cdbe37a2c7c2329c28fb4453019aec0 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-type_at.h
+++ b/level_0/f_file/tests/unit/c/test-file-type_at.h
@@ -22,9 +22,7 @@ extern void test__f_file_type_at__fails(void **state);
  *
  * @see f_file_type_at()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_type_at__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_type_at__parameter_checking(void **state);
 
 /**
  * Test that function works but the path is empty.

diff --git a/level_0/f_file/tests/unit/c/test-file-umask_get.c b/level_0/f_file/tests/unit/c/test-file-umask_get.c
index d9cd6e1bcb7d24ea5138e58d6d5ae5703fa0e25f..77da3e830b75d307dbd6c926dbd6088fdbf4f1c4 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-umask_get.c
+++ b/level_0/f_file/tests/unit/c/test-file-umask_get.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_umask_get__parameter_checking(void **state) {
+void test__f_file_umask_get__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_file_umask_get(0);
+  {
+    const f_status_t status = f_file_umask_get(0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_umask_get__works(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-umask_get.h b/level_0/f_file/tests/unit/c/test-file-umask_get.h
index b3574e84bab3bc19b20e3dc5cec06b04c5a0170e..2dab7ea959188ca63ce28c7554a923460ad4999c 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-umask_get.h
+++ b/level_0/f_file/tests/unit/c/test-file-umask_get.h
@@ -15,9 +15,7 @@
  *
  * @see f_file_umask_get()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_umask_get__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_umask_get__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_file/tests/unit/c/test-file-write.c b/level_0/f_file/tests/unit/c/test-file-write.c
index 301bf7062b4c1874676cfdae48c42501273be597..3393cbc1cabe3076075c390c725881e288d18416 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write.c
+++ b/level_0/f_file/tests/unit/c/test-file-write.c
@@ -65,19 +65,17 @@ void test__f_file_write__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_write__parameter_checking(void **state) {
+void test__f_file_write__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    {
-      const f_status_t status = f_file_write(file, f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_write(file, f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_write__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-write.h b/level_0/f_file/tests/unit/c/test-file-write.h
index 39f3fd912762aedf0453c0dda9b1ac6419e7a079..797291eca6c0f00694f7997a1c55436cae75390c 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write.h
+++ b/level_0/f_file/tests/unit/c/test-file-write.h
@@ -22,9 +22,7 @@ extern void test__f_file_write__fails(void **state);
  *
  * @see f_file_write()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_write__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_write__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-write_block.c b/level_0/f_file/tests/unit/c/test-file-write_block.c
index 406923d35614f083ff2e812190c1ec75c9fb8da9..1db4be29ed3c469c2889efb9a05305326f3a5d5e 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write_block.c
+++ b/level_0/f_file/tests/unit/c/test-file-write_block.c
@@ -48,19 +48,17 @@ void test__f_file_write_block__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_write_block__parameter_checking(void **state) {
+void test__f_file_write_block__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    {
-      const f_status_t status = f_file_write_block(file, f_string_empty_s, 0);
+  {
+    const f_status_t status = f_file_write_block(file, f_string_empty_s, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_write_block__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-write_block.h b/level_0/f_file/tests/unit/c/test-file-write_block.h
index efebb314432a667a365c6efc20ae3004e2831d72..8dd23af1f3d306e26bc5349845a666bb80fe5027 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write_block.h
+++ b/level_0/f_file/tests/unit/c/test-file-write_block.h
@@ -22,9 +22,7 @@ extern void test__f_file_write_block__fails(void **state);
  *
  * @see f_file_write_block()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_write_block__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_write_block__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-write_range.c b/level_0/f_file/tests/unit/c/test-file-write_range.c
index 3cb1f65ed0eac186247a5461250655ee8e847fb3..be959334d167698575a9b4589774e958ad2eacda 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write_range.c
+++ b/level_0/f_file/tests/unit/c/test-file-write_range.c
@@ -49,21 +49,19 @@ void test__f_file_write_range__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_write_range__parameter_checking(void **state) {
+void test__f_file_write_range__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    const f_string_range_t range = f_string_range_t_initialize;
+  const f_string_range_t range = f_string_range_t_initialize;
 
-    {
-      const f_status_t status = f_file_write_range(file, f_string_empty_s, range, 0);
+  {
+    const f_status_t status = f_file_write_range(file, f_string_empty_s, range, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_write_range__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-write_range.h b/level_0/f_file/tests/unit/c/test-file-write_range.h
index ee6b2230c79bc6df3af84ed96ff4bb40b5146b74..cbc1c606cabaa6369c9067f3f95efe47efe337a3 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write_range.h
+++ b/level_0/f_file/tests/unit/c/test-file-write_range.h
@@ -22,9 +22,7 @@ extern void test__f_file_write_range__fails(void **state);
  *
  * @see f_file_write_range()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_write_range__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_write_range__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_file/tests/unit/c/test-file-write_until.c b/level_0/f_file/tests/unit/c/test-file-write_until.c
index aa71a6d22576838a62a5a6543cec02c7de0e4fe7..771b7c27d5f3334fbefa6c8756bd6c90bb7c22d5 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write_until.c
+++ b/level_0/f_file/tests/unit/c/test-file-write_until.c
@@ -48,19 +48,17 @@ void test__f_file_write_until__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_file_write_until__parameter_checking(void **state) {
+void test__f_file_write_until__parameter_checking(void **state) {
 
-    f_file_t file = f_file_t_initialize;
-    file.size_write = 0;
+  f_file_t file = f_file_t_initialize;
+  file.size_write = 0;
 
-    {
-      const f_status_t status = f_file_write_until(file, f_string_empty_s, 0, 0);
+  {
+    const f_status_t status = f_file_write_until(file, f_string_empty_s, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_file_write_until__returns_file_closed(void **state) {
 

diff --git a/level_0/f_file/tests/unit/c/test-file-write_until.h b/level_0/f_file/tests/unit/c/test-file-write_until.h
index 03e9df7fda0c67aa6d56194740d300799ce4cd7c..ecfec2686afad118852d39e976f59041572433c2 100644 (file)
--- a/level_0/f_file/tests/unit/c/test-file-write_until.h
+++ b/level_0/f_file/tests/unit/c/test-file-write_until.h
@@ -22,9 +22,7 @@ extern void test__f_file_write_until__fails(void **state);
  *
  * @see f_file_write_until()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_file_write_until__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_file_write_until__parameter_checking(void **state);
 
 /**
  * Test that function works but the file is closed.

diff --git a/level_0/f_iki/tests/unit/c/test-iki-content_is.c b/level_0/f_iki/tests/unit/c/test-iki-content_is.c
index f66e749336d1cf04badd0fe9777b788ef2615478..5675ffced35571b31c4bae36001c8c377d58ea95 100644 (file)
--- a/level_0/f_iki/tests/unit/c/test-iki-content_is.c
+++ b/level_0/f_iki/tests/unit/c/test-iki-content_is.c
@@ -41,16 +41,14 @@ void test__f_iki_content_is__returns_false(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_iki_content_is__parameter_checking(void **state) {
+void test__f_iki_content_is__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_iki_content_is(f_string_empty_s, f_string_empty_s);
+  {
+    const f_status_t status = f_iki_content_is(f_string_empty_s, f_string_empty_s);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_iki_content_is__returns_data_not(void **state) {
 

diff --git a/level_0/f_iki/tests/unit/c/test-iki-content_is.h b/level_0/f_iki/tests/unit/c/test-iki-content_is.h
index c876cb619df8760c09da92a5cd4997c88f42a0f4..d33f1db2a27e0aa30d130579654c5a2c4622ee0c 100644 (file)
--- a/level_0/f_iki/tests/unit/c/test-iki-content_is.h
+++ b/level_0/f_iki/tests/unit/c/test-iki-content_is.h
@@ -22,9 +22,7 @@ extern void test__f_iki_content_is__returns_false(void **state);
  *
  * @see f_iki_content_is()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_iki_content_is__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_iki_content_is__parameter_checking(void **state);
 
 /**
  * Test that function returns F_data_not.

diff --git a/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.c b/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.c
index c039071a6af1c3ff40eda741f0fc2c066ec37a1c..a31c0629354997fa3d2b46fb3b88a36a1becdc49 100644 (file)
--- a/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.c
+++ b/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.c
@@ -57,18 +57,16 @@ void test__f_iki_content_partial_is__returns_false(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_iki_content_partial_is__parameter_checking(void **state) {
+void test__f_iki_content_partial_is__parameter_checking(void **state) {
 
-    {
-      const f_string_range_t range = f_string_range_t_initialize;
+  {
+    const f_string_range_t range = f_string_range_t_initialize;
 
-      const f_status_t status = f_iki_content_partial_is(f_string_empty_s, range, f_string_empty_s);
+    const f_status_t status = f_iki_content_partial_is(f_string_empty_s, range, f_string_empty_s);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_iki_content_partial_is__returns_data_not(void **state) {
 

diff --git a/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.h b/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.h
index b411147751c5b848d50ec227e5f245fa8b59df96..01b05b90726ba1c5d5b718fdbf664d85ddb5d66c 100644 (file)
--- a/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.h
+++ b/level_0/f_iki/tests/unit/c/test-iki-content_partial_is.h
@@ -22,9 +22,7 @@ extern void test__f_iki_content_partial_is__returns_false(void **state);
  *
  * @see f_iki_content_partial_is()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_iki_content_partial_is__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_iki_content_partial_is__parameter_checking(void **state);
 
 /**
  * Test that function returns F_data_not.

diff --git a/level_0/f_iki/tests/unit/c/test-iki-read.c b/level_0/f_iki/tests/unit/c/test-iki-read.c
index 1f6a02d0de5e1dd6ddd72108d8f7ad9d410cbfef..7092e7132b25dd573a5e0d78e11fcc4fbcf04b69 100644 (file)
--- a/level_0/f_iki/tests/unit/c/test-iki-read.c
+++ b/level_0/f_iki/tests/unit/c/test-iki-read.c
@@ -5,38 +5,36 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_iki_read__parameter_checking(void **state) {
+void test__f_iki_read__parameter_checking(void **state) {
 
-    const f_state_t the_state = f_state_t_initialize;
-    f_string_static_t empty = macro_f_string_static_t_initialize(f_string_empty_s.string, f_string_empty_s.size, f_string_empty_s.used);
+  const f_state_t the_state = f_state_t_initialize;
+  f_string_static_t empty = macro_f_string_static_t_initialize(f_string_empty_s.string, f_string_empty_s.size, f_string_empty_s.used);
 
-    {
-      f_string_range_t range = f_string_range_t_initialize;
-      f_iki_data_t iki = f_iki_data_t_initialize;
+  {
+    f_string_range_t range = f_string_range_t_initialize;
+    f_iki_data_t iki = f_iki_data_t_initialize;
 
-      const f_status_t status = f_iki_read(the_state, 0, &range, &iki);
+    const f_status_t status = f_iki_read(the_state, 0, &range, &iki);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_iki_data_t iki = f_iki_data_t_initialize;
+  {
+    f_iki_data_t iki = f_iki_data_t_initialize;
 
-      const f_status_t status = f_iki_read(the_state, &empty, 0, &iki);
+    const f_status_t status = f_iki_read(the_state, &empty, 0, &iki);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      f_string_range_t range = f_string_range_t_initialize;
+  {
+    f_string_range_t range = f_string_range_t_initialize;
 
-      const f_status_t status = f_iki_read(the_state, &empty, &range, 0);
+    const f_status_t status = f_iki_read(the_state, &empty, &range, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_iki_read__returns_data_not(void **state) {
 

diff --git a/level_0/f_iki/tests/unit/c/test-iki-read.h b/level_0/f_iki/tests/unit/c/test-iki-read.h
index 16dba9f37fe68f3399643528c95016a29467edc8..282c1c38e237f6c93fac4c142b353223778b8f20 100644 (file)
--- a/level_0/f_iki/tests/unit/c/test-iki-read.h
+++ b/level_0/f_iki/tests/unit/c/test-iki-read.h
@@ -15,9 +15,7 @@
  *
  * @see f_iki_read()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_iki_read__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_iki_read__parameter_checking(void **state);
 
 /**
  * Test that function returns F_data_not.

diff --git a/level_0/f_limit/tests/unit/c/test-limit-process.c b/level_0/f_limit/tests/unit/c/test-limit-process.c
index a073c628551094f92a24c84516d773e54bae1063..53bff776f737e0e5b363824dd9b87f5791efb023 100644 (file)
--- a/level_0/f_limit/tests/unit/c/test-limit-process.c
+++ b/level_0/f_limit/tests/unit/c/test-limit-process.c
@@ -36,16 +36,14 @@ void test__f_limit_process__fails(void **state) {
   } // for
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_limit_process__parameter_checking(void **state) {
+void test__f_limit_process__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_limit_process(1, 1, 0, 0);
+  {
+    const f_status_t status = f_limit_process(1, 1, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_limit_process__works(void **state) {
 

diff --git a/level_0/f_limit/tests/unit/c/test-limit-process.h b/level_0/f_limit/tests/unit/c/test-limit-process.h
index 783f618289238b2e22c9ca12d99353390d2d78f3..f746b083bb1b48604021680bcd1f93dbd487c31e 100644 (file)
--- a/level_0/f_limit/tests/unit/c/test-limit-process.h
+++ b/level_0/f_limit/tests/unit/c/test-limit-process.h
@@ -22,9 +22,7 @@ extern void test__f_limit_process__fails(void **state);
  *
  * @see f_limit_process()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_limit_process__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_limit_process__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_memory/tests/unit/c/test-memory-adjust.c b/level_0/f_memory/tests/unit/c/test-memory-adjust.c
index 04b911e296d918bf05d92fa5f0e9b3f7a4f8e459..103a3fe703313d0a6b2d3e95ac419976eda45a8b 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-adjust.c
+++ b/level_0/f_memory/tests/unit/c/test-memory-adjust.c
@@ -5,22 +5,20 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_memory_adjust__parameter_checking(void **state) {
+void test__f_memory_adjust__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_memory_adjust(1, 4, 0, 0);
+  {
+    const f_status_t status = f_memory_adjust(1, 4, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_memory_adjust(1, 4, 1, 0);
+  {
+    const f_status_t status = f_memory_adjust(1, 4, 1, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_memory_adjust__works(void **state) {
 

diff --git a/level_0/f_memory/tests/unit/c/test-memory-adjust.h b/level_0/f_memory/tests/unit/c/test-memory-adjust.h
index 534080e82347e99397d20dc0a325412b6080be05..7436da51e26cd8c806328d7efc483ddbf985bc4d 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-adjust.h
+++ b/level_0/f_memory/tests/unit/c/test-memory-adjust.h
@@ -15,9 +15,7 @@
  *
  * @see f_memory_adjust()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_memory_adjust__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_memory_adjust__parameter_checking(void **state);
 
 /**
  * Test that reallocation works.

diff --git a/level_0/f_memory/tests/unit/c/test-memory-delete.c b/level_0/f_memory/tests/unit/c/test-memory-delete.c
index 44522d3eedab0a044bd6d22f2a1b104fca679e00..1caf20e20b94299b1762899cc1b2c9dc418ac5de 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-delete.c
+++ b/level_0/f_memory/tests/unit/c/test-memory-delete.c
@@ -95,16 +95,14 @@ void test__f_memory_delete__frees_resized_memory(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_memory_delete__parameter_checking(void **state) {
+void test__f_memory_delete__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_memory_delete(4, 0, 0);
+  {
+    const f_status_t status = f_memory_delete(4, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 #ifdef __cplusplus
 } // extern "C"

diff --git a/level_0/f_memory/tests/unit/c/test-memory-delete.h b/level_0/f_memory/tests/unit/c/test-memory-delete.h
index fe9626ca657ec7ac4a842016b7209b6316b73176..b840a322bac8fab1c45ac397fc253751e8b328ca 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-delete.h
+++ b/level_0/f_memory/tests/unit/c/test-memory-delete.h
@@ -49,8 +49,6 @@ extern void test__f_memory_delete__frees_resized_memory(void **state);
  *
  * @see f_memory_delete()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_memory_delete__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_memory_delete__parameter_checking(void **state);
 
 #endif // _TEST__F_memory__delete

diff --git a/level_0/f_memory/tests/unit/c/test-memory-destroy.c b/level_0/f_memory/tests/unit/c/test-memory-destroy.c
index 9b844eedc84a6ca21b17af6cb48c42ed9a93f93c..a70a340a8a3254c5513d879b77970977a817b7fc 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-destroy.c
+++ b/level_0/f_memory/tests/unit/c/test-memory-destroy.c
@@ -95,16 +95,14 @@ void test__f_memory_destroy__frees_resized_memory(void **state) {
   }
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_memory_destroy__parameter_checking(void **state) {
+void test__f_memory_destroy__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_memory_destroy(4, 0, 0);
+  {
+    const f_status_t status = f_memory_destroy(4, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 #ifdef __cplusplus
 } // extern "C"

diff --git a/level_0/f_memory/tests/unit/c/test-memory-destroy.h b/level_0/f_memory/tests/unit/c/test-memory-destroy.h
index 561aec2f755843d6d468fa9df7a591604dc4c4f3..ab9d4b15907d43efd3e9967f2c76018f276d6d38 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-destroy.h
+++ b/level_0/f_memory/tests/unit/c/test-memory-destroy.h
@@ -49,8 +49,6 @@ extern void test__f_memory_destroy__frees_resized_memory(void **state);
  *
  * @see f_memory_destroy()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_memory_destroy__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_memory_destroy__parameter_checking(void **state);
 
 #endif // _TEST__F_memory__destroy

diff --git a/level_0/f_memory/tests/unit/c/test-memory-new.c b/level_0/f_memory/tests/unit/c/test-memory-new.c
index 66d3a46a045fa95e7645d49d60de06164f5af509..1b91af3cad1327160f01e467f95531bc1626b891 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-new.c
+++ b/level_0/f_memory/tests/unit/c/test-memory-new.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_memory_new__parameter_checking(void **state) {
+void test__f_memory_new__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_memory_new(1, 0, 0);
+  {
+    const f_status_t status = f_memory_new(1, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_memory_new__works(void **state) {
 

diff --git a/level_0/f_memory/tests/unit/c/test-memory-new.h b/level_0/f_memory/tests/unit/c/test-memory-new.h
index a3ab86709a48f9e068a5bb6095034ea4ffebb42f..4fdb6d302314a4c92eb20f2f80d6809042c176a7 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-new.h
+++ b/level_0/f_memory/tests/unit/c/test-memory-new.h
@@ -15,9 +15,7 @@
  *
  * @see f_memory_new()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_memory_new__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_memory_new__parameter_checking(void **state);
 
 /**
  * Test that allocation works.

diff --git a/level_0/f_memory/tests/unit/c/test-memory-new_aligned.c b/level_0/f_memory/tests/unit/c/test-memory-new_aligned.c
index 990a7b098020b8799f13ea5407e8494fc84a64aa..34c4dab7ed80c3d73f0fdf22d3f4114ba66f7b47 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-new_aligned.c
+++ b/level_0/f_memory/tests/unit/c/test-memory-new_aligned.c
@@ -5,16 +5,14 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_memory_new_aligned__parameter_checking(void **state) {
+void test__f_memory_new_aligned__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_memory_new_aligned(1, 0, 0);
+  {
+    const f_status_t status = f_memory_new_aligned(1, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_memory_new_aligned__works(void **state) {
 

diff --git a/level_0/f_memory/tests/unit/c/test-memory-new_aligned.h b/level_0/f_memory/tests/unit/c/test-memory-new_aligned.h
index 9b520f69a276b40a51510d14fbb443c7a3cc0170..8c4e6e95f1b4ee419bab3d191780984d2ca773aa 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-new_aligned.h
+++ b/level_0/f_memory/tests/unit/c/test-memory-new_aligned.h
@@ -15,9 +15,7 @@
  *
  * @see f_memory_new_aligned()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_memory_new_aligned__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_memory_new_aligned__parameter_checking(void **state);
 
 /**
  * Test that allocation works.

diff --git a/level_0/f_memory/tests/unit/c/test-memory-resize.c b/level_0/f_memory/tests/unit/c/test-memory-resize.c
index 4ea57d8e58cc50e99a4f0e213e432649e788117f..4fa5c6cdb07fef59fc158a132199b0c94d09f158 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-resize.c
+++ b/level_0/f_memory/tests/unit/c/test-memory-resize.c
@@ -5,22 +5,20 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_memory_resize__parameter_checking(void **state) {
+void test__f_memory_resize__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_memory_resize(1, 4, 0, 0);
+  {
+    const f_status_t status = f_memory_resize(1, 4, 0, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
+  }
 
-    {
-      const f_status_t status = f_memory_resize(1, 4, 1, 0);
+  {
+    const f_status_t status = f_memory_resize(1, 4, 1, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_memory_resize__works(void **state) {
 

diff --git a/level_0/f_memory/tests/unit/c/test-memory-resize.h b/level_0/f_memory/tests/unit/c/test-memory-resize.h
index 58efe233d1c434a76ed0b30aa5bbe5a351e03b32..ca8c5b65587130a6a0c99c8529ff28510b1bd163 100644 (file)
--- a/level_0/f_memory/tests/unit/c/test-memory-resize.h
+++ b/level_0/f_memory/tests/unit/c/test-memory-resize.h
@@ -15,9 +15,7 @@
  *
  * @see f_memory_resize()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_memory_resize__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_memory_resize__parameter_checking(void **state);
 
 /**
  * Test that reallocation works.

diff --git a/level_0/f_path/tests/unit/c/test-path-current.c b/level_0/f_path/tests/unit/c/test-path-current.c
index e592b901d4d1574fb2a974002438ad656f1a6e49..56c7ba90459fdc7dabd47297cf2e1fd78cfb93a8 100644 (file)
--- a/level_0/f_path/tests/unit/c/test-path-current.c
+++ b/level_0/f_path/tests/unit/c/test-path-current.c
@@ -87,16 +87,14 @@ void test__f_path_current__fails(void **state) {
   f_string_dynamic_resize(0, &destination);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_path_current__parameter_checking(void **state) {
+void test__f_path_current__parameter_checking(void **state) {
 
-    {
-      const f_status_t status = f_path_current(F_false, 0);
+  {
+    const f_status_t status = f_path_current(F_false, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_path_current__works(void **state) {
 

diff --git a/level_0/f_path/tests/unit/c/test-path-current.h b/level_0/f_path/tests/unit/c/test-path-current.h
index a9ff7d3082e425805f6c67c24f36b09cd1d9e333..17084324e1edd97c42d4f265e962f442eb22a821 100644 (file)
--- a/level_0/f_path/tests/unit/c/test-path-current.h
+++ b/level_0/f_path/tests/unit/c/test-path-current.h
@@ -22,9 +22,7 @@ extern void test__f_path_current__fails(void **state);
  *
  * @see f_path_current()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_path_current__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_path_current__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_path/tests/unit/c/test-path-directory_cleanup.c b/level_0/f_path/tests/unit/c/test-path-directory_cleanup.c
index 889f038e6e196a91d9af1830bf4d65e9751f836b..9ead9b90b80dcf815dd3c433f72e39bde6e34a21 100644 (file)
--- a/level_0/f_path/tests/unit/c/test-path-directory_cleanup.c
+++ b/level_0/f_path/tests/unit/c/test-path-directory_cleanup.c
@@ -5,18 +5,16 @@
 extern "C" {
 #endif
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_path_directory_cleanup__parameter_checking(void **state) {
+void test__f_path_directory_cleanup__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_path_directory_cleanup(path, 0);
+  {
+    const f_status_t status = f_path_directory_cleanup(path, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_path_directory_cleanup__works(void **state) {
 

diff --git a/level_0/f_path/tests/unit/c/test-path-directory_cleanup.h b/level_0/f_path/tests/unit/c/test-path-directory_cleanup.h
index 6c645161144794aa28f371e00857e4382bec4b32..2b67a89dc473553d15a968ccd72533483358c141 100644 (file)
--- a/level_0/f_path/tests/unit/c/test-path-directory_cleanup.h
+++ b/level_0/f_path/tests/unit/c/test-path-directory_cleanup.h
@@ -15,9 +15,7 @@
  *
  * @see f_path_directory_cleanup()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_path_directory_cleanup__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_path_directory_cleanup__parameter_checking(void **state);
 
 /**
  * Test that function works.

diff --git a/level_0/f_path/tests/unit/c/test-path-real.c b/level_0/f_path/tests/unit/c/test-path-real.c
index 7cf24c353f8b9461784073e767daaa847b565361..b6d297421ff38521bc88e9dc5fafc35ddd06587f 100644 (file)
--- a/level_0/f_path/tests/unit/c/test-path-real.c
+++ b/level_0/f_path/tests/unit/c/test-path-real.c
@@ -48,18 +48,16 @@ void test__f_path_real__fails(void **state) {
   f_string_dynamic_resize(0, &destination);
 }
 
-#ifndef _di_level_0_parameter_checking_
-  void test__f_path_real__parameter_checking(void **state) {
+void test__f_path_real__parameter_checking(void **state) {
 
-    const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
+  const f_string_static_t path = macro_f_string_static_t_initialize("test", 0, 4);
 
-    {
-      const f_status_t status = f_path_real(path, 0);
+  {
+    const f_status_t status = f_path_real(path, 0);
 
-      assert_int_equal(status, F_status_set_error(F_parameter));
-    }
+    assert_int_equal(status, F_status_set_error(F_parameter));
   }
-#endif // _di_level_0_parameter_checking_
+}
 
 void test__f_path_real__works(void **state) {
 

diff --git a/level_0/f_path/tests/unit/c/test-path-real.h b/level_0/f_path/tests/unit/c/test-path-real.h
index c6af1baf96a77d8fb31132e232b32017fcdb1342..794eaacd02d26f82bcedb6f5c415cb820c05e702 100644 (file)
--- a/level_0/f_path/tests/unit/c/test-path-real.h
+++ b/level_0/f_path/tests/unit/c/test-path-real.h
@@ -22,9 +22,7 @@ extern void test__f_path_real__fails(void **state);
  *
  * @see f_path_real()
  */
-#ifndef _di_level_0_parameter_checking_
-  extern void test__f_path_real__parameter_checking(void **state);
-#endif // _di_level_0_parameter_checking_
+extern void test__f_path_real__parameter_checking(void **state);
 
 /**
  * Test that function works.