Cleanup: Warning in unit f_utf tests under GCC 14 regarding type.

The string comparison of an integer based value is correct.
Add an explicit cast to make this intent clear and to silence the warnings.

diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c
index 2aa8e20864f3240a825f4100fac497a0e5803653..21f5fbae3775737ac2296c1fdec5955ff893fa64 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append.c
@@ -55,9 +55,9 @@ void test__f_utf_string_map_multis_append__works(void **state) {
     assert_int_equal(destination.array[0].value.array[0].used, source.value.array[0].used);
     assert_int_equal(destination.array[0].value.array[1].used, source.value.array[1].used);
 
-    assert_string_equal(destination.array[0].key.string, source.key.string);
-    assert_string_equal(destination.array[0].value.array[0].string, source.value.array[0].string);
-    assert_string_equal(destination.array[0].value.array[1].string, source.value.array[1].string);
+    assert_string_equal((const char * const) destination.array[0].key.string, (const char * const) source.key.string);
+    assert_string_equal((const char * const) destination.array[0].value.array[0].string, (const char * const) source.value.array[0].string);
+    assert_string_equal((const char * const) destination.array[0].value.array[1].string, (const char * const) source.value.array[1].string);
 
     for (f_number_unsigned_t j = 0; j < destination.array[0].key.used; ++j) {
       assert_int_equal(destination.array[0].key.string[j], source.key.string[j]);

diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c
index 03b97d52ac4cd6a52b0963e82ccb1773ce0c4258..5614a7206ec51944f90ca8547474236e2bf258e5 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multis_append_all.c
@@ -31,7 +31,7 @@ void test__f_utf_string_map_multis_append_all__works(void **state) {
       status = f_utf_string_dynamic_append(test_key, &source.array[source.used].key);
 
       assert_int_equal(status, F_okay);
-      assert_string_equal(source.array[source.used].key.string, test_key.string);
+      assert_string_equal((const char * const) source.array[source.used].key.string, (const char * const) test_key.string);
       assert_int_equal(source.array[source.used].key.used, test_key.used);
 
       status = f_utf_string_dynamics_append_all(test_value, &source.array[source.used].value);
@@ -39,8 +39,8 @@ void test__f_utf_string_map_multis_append_all__works(void **state) {
       assert_int_equal(status, F_okay);
       assert_int_equal(source.array[source.used].value.array[0].used, test_value.array[0].used);
       assert_int_equal(source.array[source.used].value.array[1].used, test_value.array[1].used);
-      assert_string_equal(source.array[source.used].value.array[0].string, test_value.array[0].string);
-      assert_string_equal(source.array[source.used].value.array[1].string, test_value.array[1].string);
+      assert_string_equal((const char * const) source.array[source.used].value.array[0].string, (const char * const) test_value.array[0].string);
+      assert_string_equal((const char * const) source.array[source.used].value.array[1].string, (const char * const) test_value.array[1].string);
     } // for
   }
 
@@ -58,9 +58,9 @@ void test__f_utf_string_map_multis_append_all__works(void **state) {
       assert_int_equal(destination.array[i].value.array[0].used, source.array[i].value.array[0].used);
       assert_int_equal(destination.array[i].value.array[1].used, source.array[i].value.array[1].used);
 
-      assert_string_equal(destination.array[i].key.string, source.array[i].key.string);
-      assert_string_equal(destination.array[i].value.array[0].string, source.array[i].value.array[0].string);
-      assert_string_equal(destination.array[i].value.array[1].string, source.array[i].value.array[1].string);
+      assert_string_equal((const char * const) destination.array[i].key.string, (const char * const) source.array[i].key.string);
+      assert_string_equal((const char * const) destination.array[i].value.array[0].string, (const char * const) source.array[i].value.array[0].string);
+      assert_string_equal((const char * const) destination.array[i].value.array[1].string, (const char * const) source.array[i].value.array[1].string);
     } // for
   }
 

diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c
index cf3d8d114775b2894c7dbe14fad9cac535c944b8..f4b4dd0f063338cd555e2ec4b463c8b867b3f10e 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append.c
@@ -43,7 +43,7 @@ void test__f_utf_string_map_multiss_append__works(void **state) {
       status = f_utf_string_dynamic_append(test_names[source.used], &source.array[source.used].key);
 
       assert_int_equal(status, F_okay);
-      assert_string_equal(source.array[source.used].key.string, test_names[source.used].string);
+      assert_string_equal((const char * const) source.array[source.used].key.string, (const char * const) test_names[source.used].string);
       assert_int_equal(source.array[source.used].key.used, test_names[source.used].used);
 
       status = f_utf_string_dynamics_append_all(test_values[source.used], &source.array[source.used].value);
@@ -53,8 +53,8 @@ void test__f_utf_string_map_multiss_append__works(void **state) {
       assert_int_equal(source.array[source.used].value.array[0].used, test_values[source.used].array[0].used);
       assert_int_equal(source.array[source.used].value.array[1].used, test_values[source.used].array[1].used);
 
-      assert_string_equal(source.array[source.used].value.array[0].string, test_values[source.used].array[0].string);
-      assert_string_equal(source.array[source.used].value.array[1].string, test_values[source.used].array[1].string);
+      assert_string_equal((const char * const) source.array[source.used].value.array[0].string, (const char * const) test_values[source.used].array[0].string);
+      assert_string_equal((const char * const) source.array[source.used].value.array[1].string, (const char * const) test_values[source.used].array[1].string);
     } // for
   }
 
@@ -71,9 +71,9 @@ void test__f_utf_string_map_multiss_append__works(void **state) {
       assert_int_equal(destination.array[0].array[i].value.array[0].used, test_values[i].array[0].used);
       assert_int_equal(destination.array[0].array[i].value.array[1].used, test_values[i].array[1].used);
 
-      assert_string_equal(destination.array[0].array[i].key.string, test_names[i].string);
-      assert_string_equal(destination.array[0].array[i].value.array[0].string, test_values[i].array[0].string);
-      assert_string_equal(destination.array[0].array[i].value.array[1].string, test_values[i].array[1].string);
+      assert_string_equal((const char * const) destination.array[0].array[i].key.string, (const char * const) test_names[i].string);
+      assert_string_equal((const char * const) destination.array[0].array[i].value.array[0].string, (const char * const) test_values[i].array[0].string);
+      assert_string_equal((const char * const) destination.array[0].array[i].value.array[1].string, (const char * const) test_values[i].array[1].string);
     } // for
   }
 

diff --git a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c
index 09f1e3551e32f014a1e2aababf84b77daae476c6..144597f1c0ee0765a1ee9ba8e2908ad7f36d7e84 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-map_multiss_append_all.c
@@ -56,7 +56,7 @@ void test__f_utf_string_map_multiss_append_all__works(void **state) {
 
         assert_int_equal(status, F_okay);
         assert_int_equal(source.array[source.used].array[i].key.used, test_names[i].used);
-        assert_string_equal(source.array[source.used].array[i].key.string, test_names[i].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].key.string, (const char * const) test_names[i].string);
 
         status = f_utf_string_dynamics_append_all(test_values[i], &source.array[source.used].array[i].value);
 
@@ -65,8 +65,8 @@ void test__f_utf_string_map_multiss_append_all__works(void **state) {
         assert_int_equal(source.array[source.used].array[i].value.array[0].used, test_values[i].array[0].used);
         assert_int_equal(source.array[source.used].array[i].value.array[1].used, test_values[i].array[1].used);
 
-        assert_string_equal(source.array[source.used].array[i].value.array[0].string, test_values[i].array[0].string);
-        assert_string_equal(source.array[source.used].array[i].value.array[1].string, test_values[i].array[1].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].value.array[0].string, (const char * const) test_values[i].array[0].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].value.array[1].string, (const char * const) test_values[i].array[1].string);
       } // for
 
       source.array[source.used].used = length_inner;
@@ -88,9 +88,9 @@ void test__f_utf_string_map_multiss_append_all__works(void **state) {
         assert_int_equal(destination.array[j].array[i].value.array[0].used, test_values[i].array[0].used);
         assert_int_equal(destination.array[j].array[i].value.array[1].used, test_values[i].array[1].used);
 
-        assert_string_equal(destination.array[j].array[i].key.string, test_names[i].string);
-        assert_string_equal(destination.array[j].array[i].value.array[0].string, test_values[i].array[0].string);
-        assert_string_equal(destination.array[j].array[i].value.array[1].string, test_values[i].array[1].string);
+        assert_string_equal((const char * const) destination.array[j].array[i].key.string, (const char * const) test_names[i].string);
+        assert_string_equal((const char * const) destination.array[j].array[i].value.array[0].string, (const char * const) test_values[i].array[0].string);
+        assert_string_equal((const char * const) destination.array[j].array[i].value.array[1].string, (const char * const) test_values[i].array[1].string);
       } // for
     } // for
   }

diff --git a/level_0/f_utf/tests/unit/c/test-utf-maps_append.c b/level_0/f_utf/tests/unit/c/test-utf-maps_append.c
index b9d7b915c21f4d60c6aba5c9b874653379340f0b..6bf5e960bf38ef7b9662ac703ae274cb0f0e1784 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-maps_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-maps_append.c
@@ -17,13 +17,13 @@ void test__f_utf_string_maps_append__works(void **state) {
     f_status_t status = f_utf_string_dynamic_append(test_key, &source.key);
 
     assert_int_equal(status, F_okay);
-    assert_string_equal(source.key.string, test_key.string);
+    assert_string_equal((const char * const) source.key.string, (const char * const) test_key.string);
     assert_int_equal(source.key.used, test_key.used);
 
     status = f_utf_string_dynamic_append(test_value, &source.value);
 
     assert_int_equal(status, F_okay);
-    assert_string_equal(source.value.string, test_value.string);
+    assert_string_equal((const char * const) source.value.string, (const char * const) test_value.string);
     assert_int_equal(source.value.used, test_value.used);
   }
 
@@ -34,8 +34,8 @@ void test__f_utf_string_maps_append__works(void **state) {
     assert_int_equal(destination.used, 1);
     assert_int_equal(destination.array[0].key.used, source.key.used);
     assert_int_equal(destination.array[0].value.used, source.value.used);
-    assert_string_equal(destination.array[0].key.string, source.key.string);
-    assert_string_equal(destination.array[0].value.string, source.value.string);
+    assert_string_equal((const char * const) destination.array[0].key.string, (const char * const) source.key.string);
+    assert_string_equal((const char * const) destination.array[0].value.string, (const char * const) source.value.string);
   }
 
   free((void *) source.key.string);

diff --git a/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c
index e397e24028b3ae18d18116489a26f3e2372f52b4..624893b86a0c14479d0b2ceb660f5eb7e3720604 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-maps_append_all.c
@@ -25,13 +25,13 @@ void test__f_utf_string_maps_append_all__works(void **state) {
       status = f_utf_string_dynamic_append(test_key, &source.array[source.used].key);
 
       assert_int_equal(status, F_okay);
-      assert_string_equal(source.array[source.used].key.string, test_key.string);
+      assert_string_equal((const char * const) source.array[source.used].key.string, (const char * const) test_key.string);
       assert_int_equal(source.array[source.used].key.used, test_key.used);
 
       status = f_utf_string_dynamic_append(test_value, &source.array[source.used].value);
 
       assert_int_equal(status, F_okay);
-      assert_string_equal(source.array[source.used].value.string, test_value.string);
+      assert_string_equal((const char * const) source.array[source.used].value.string, (const char * const) test_value.string);
       assert_int_equal(source.array[source.used].value.used, test_value.used);
     } // for
   }
@@ -48,8 +48,8 @@ void test__f_utf_string_maps_append_all__works(void **state) {
       assert_int_equal(destination.array[i].key.used, source.array[i].key.used);
       assert_int_equal(destination.array[i].value.used, source.array[i].value.used);
 
-      assert_string_equal(destination.array[i].key.string, source.array[i].key.string);
-      assert_string_equal(destination.array[i].value.string, source.array[i].value.string);
+      assert_string_equal((const char * const) destination.array[i].key.string, (const char * const) source.array[i].key.string);
+      assert_string_equal((const char * const) destination.array[i].value.string, (const char * const) source.array[i].value.string);
     } // for
   }
 

diff --git a/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c b/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c
index eccbb107d6df05266f43d8b0b4672f7ff482ccc8..be6aa4786f2344323296872a594caf7011303460 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mapss_append.c
@@ -32,13 +32,13 @@ void test__f_utf_string_mapss_append__works(void **state) {
       status = f_utf_string_dynamic_append(test_names[source.used], &source.array[source.used].key);
 
       assert_int_equal(status, F_okay);
-      assert_string_equal(source.array[source.used].key.string, test_names[source.used].string);
+      assert_string_equal((const char * const) source.array[source.used].key.string, (const char * const) test_names[source.used].string);
       assert_int_equal(source.array[source.used].key.used, test_names[source.used].used);
 
       status = f_utf_string_dynamic_append(test_values[source.used], &source.array[source.used].value);
 
       assert_int_equal(status, F_okay);
-      assert_string_equal(source.array[source.used].value.string, test_values[source.used].string);
+      assert_string_equal((const char * const) source.array[source.used].value.string, (const char * const) test_values[source.used].string);
       assert_int_equal(source.array[source.used].value.used, test_values[source.used].used);
     } // for
   }
@@ -54,8 +54,8 @@ void test__f_utf_string_mapss_append__works(void **state) {
       assert_int_equal(destination.array[0].array[i].key.used, test_names[i].used);
       assert_int_equal(destination.array[0].array[i].value.used, test_values[i].used);
 
-      assert_string_equal(destination.array[0].array[i].key.string, test_names[i].string);
-      assert_string_equal(destination.array[0].array[i].value.string, test_values[i].string);
+      assert_string_equal((const char * const) destination.array[0].array[i].key.string, (const char * const) test_names[i].string);
+      assert_string_equal((const char * const) destination.array[0].array[i].value.string, (const char * const) test_values[i].string);
     } // for
   }
 

diff --git a/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c
index a3d96565478f15561d7638bcf485db5d0903d9f2..4509cba3097bed3ed9a3e2e4878809724276e3cd 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-mapss_append_all.c
@@ -44,13 +44,13 @@ void test__f_utf_string_mapss_append_all__works(void **state) {
         status = f_utf_string_dynamic_append(test_names[i], &source.array[source.used].array[i].key);
 
         assert_int_equal(status, F_okay);
-        assert_string_equal(source.array[source.used].array[i].key.string, test_names[i].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].key.string, (const char * const) test_names[i].string);
         assert_int_equal(source.array[source.used].array[i].key.used, test_names[i].used);
 
         status = f_utf_string_dynamic_append(test_values[i], &source.array[source.used].array[i].value);
 
         assert_int_equal(status, F_okay);
-        assert_string_equal(source.array[source.used].array[i].value.string, test_values[i].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].value.string, (const char * const) test_values[i].string);
         assert_int_equal(source.array[source.used].array[i].value.used, test_values[i].used);
       } // for
 
@@ -71,8 +71,8 @@ void test__f_utf_string_mapss_append_all__works(void **state) {
         assert_int_equal(destination.array[j].array[i].key.used, test_names[i].used);
         assert_int_equal(destination.array[j].array[i].value.used, test_values[i].used);
 
-        assert_string_equal(destination.array[j].array[i].key.string, test_names[i].string);
-        assert_string_equal(destination.array[j].array[i].value.string, test_values[i].string);
+        assert_string_equal((const char * const) destination.array[j].array[i].key.string, (const char * const) test_names[i].string);
+        assert_string_equal((const char * const) destination.array[j].array[i].value.string, (const char * const) test_values[i].string);
       } // for
     } // for
   }

diff --git a/level_0/f_utf/tests/unit/c/test-utf-triples_append.c b/level_0/f_utf/tests/unit/c/test-utf-triples_append.c
index ccc11291399bf9e2fd381c271f6f22ff429f2267..6df419944944924ac817aad56ed13ef94da5f8eb 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-triples_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-triples_append.c
@@ -23,9 +23,9 @@ void test__f_utf_string_triples_append__works(void **state) {
     assert_int_equal(destination.array[0].b.used, source.b.used);
     assert_int_equal(destination.array[0].c.used, source.c.used);
 
-    assert_string_equal(destination.array[0].a.string, source.a.string);
-    assert_string_equal(destination.array[0].b.string, source.b.string);
-    assert_string_equal(destination.array[0].c.string, source.c.string);
+    assert_string_equal((const char * const) destination.array[0].a.string, (const char * const) source.a.string);
+    assert_string_equal((const char * const) destination.array[0].b.string, (const char * const) source.b.string);
+    assert_string_equal((const char * const) destination.array[0].c.string, (const char * const) source.c.string);
   }
 
   free((void *) destination.array[0].a.string);

diff --git a/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c
index 84da2446e58281a3f16717a502ccb6568f21ca73..f9ac703472c7720ad95b2ec95944d3de978aa74b 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-triples_append_all.c
@@ -38,9 +38,9 @@ void test__f_utf_string_triples_append_all__works(void **state) {
       assert_int_equal(destination.array[i].b.used, source.array[i].b.used);
       assert_int_equal(destination.array[i].c.used, source.array[i].c.used);
 
-      assert_string_equal(destination.array[i].a.string, source.array[i].a.string);
-      assert_string_equal(destination.array[i].b.string, source.array[i].b.string);
-      assert_string_equal(destination.array[i].c.string, source.array[i].c.string);
+      assert_string_equal((const char * const) destination.array[i].a.string, (const char * const) source.array[i].a.string);
+      assert_string_equal((const char * const) destination.array[i].b.string, (const char * const) source.array[i].b.string);
+      assert_string_equal((const char * const) destination.array[i].c.string, (const char * const) source.array[i].c.string);
     } // for
   }
 

diff --git a/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c b/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c
index 7606394a12a0de20812a1be476b07a688952922a..45be3894b671dbfe0d88f3080171bfa2c64cacff 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-tripless_append.c
@@ -37,9 +37,9 @@ void test__f_utf_string_tripless_append__works(void **state) {
       assert_int_equal(destination.array[0].array[i].b.used, sources_array[i].b.used);
       assert_int_equal(destination.array[0].array[i].c.used, sources_array[i].c.used);
 
-      assert_string_equal(destination.array[0].array[i].a.string, sources_array[i].a.string);
-      assert_string_equal(destination.array[0].array[i].b.string, sources_array[i].b.string);
-      assert_string_equal(destination.array[0].array[i].c.string, sources_array[i].c.string);
+      assert_string_equal((const char * const) destination.array[0].array[i].a.string, (const char * const) sources_array[i].a.string);
+      assert_string_equal((const char * const) destination.array[0].array[i].b.string, (const char * const) sources_array[i].b.string);
+      assert_string_equal((const char * const) destination.array[0].array[i].c.string, (const char * const) sources_array[i].c.string);
     } // for
   }
 

diff --git a/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c b/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c
index 8b420713877db04b78916d6560db03835684bc91..a074ed5f3e220c7749556c4953e8e2f2c95f77a5 100644 (file)
--- a/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c
+++ b/level_0/f_utf/tests/unit/c/test-utf-tripless_append_all.c
@@ -58,9 +58,9 @@ void test__f_utf_string_tripless_append_all__works(void **state) {
         assert_int_equal(destination.array[j].array[i].b.used, sources_set_array[j].array[i].b.used);
         assert_int_equal(destination.array[j].array[i].c.used, sources_set_array[j].array[i].c.used);
 
-        assert_string_equal(destination.array[j].array[i].a.string, sources_set_array[j].array[i].a.string);
-        assert_string_equal(destination.array[j].array[i].b.string, sources_set_array[j].array[i].b.string);
-        assert_string_equal(destination.array[j].array[i].c.string, sources_set_array[j].array[i].c.string);
+        assert_string_equal((const char * const) destination.array[j].array[i].a.string, (const char * const) sources_set_array[j].array[i].a.string);
+        assert_string_equal((const char * const) destination.array[j].array[i].b.string, (const char * const) sources_set_array[j].array[i].b.string);
+        assert_string_equal((const char * const) destination.array[j].array[i].c.string, (const char * const) sources_set_array[j].array[i].c.string);
       } // for
     } // for
   }