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 59c171371987df7052d44386bbd7c58188f66e8d..ef1faef6b60b5ce176322c4cbcffa7b65d0ecb73 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_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].name.string, source.name.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].name.string, (const char * const) source.name.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_array_length_t j = 0; j < destination.array[0].name.used; ++j) {
       assert_int_equal(destination.array[0].name.string[j], source.name.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 d9c9f29c8c536f3c8ce6a3766c2c81ddb794b591..04b985041825c1ce7a97144605201baf7ab312da 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_map_multis_append_all__works(void **state) {
       status = f_utf_string_dynamic_append(test_name, &source.array[source.used].name);
 
       assert_int_equal(status, F_none);
-      assert_string_equal(source.array[source.used].name.string, test_name.string);
+      assert_string_equal((const char * const) source.array[source.used].name.string, (const char * const) test_name.string);
       assert_int_equal(source.array[source.used].name.used, test_name.used);
 
       status = f_utf_string_dynamics_append_all(test_value, &source.array[source.used].value);
@@ -39,8 +39,8 @@ void test__f_utf_map_multis_append_all__works(void **state) {
       assert_int_equal(status, F_none);
       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_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].name.string, source.array[i].name.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].name.string, (const char * const) source.array[i].name.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 08cb2ec3a87f065cc5af070d2a6a060ccfcf7568..32096c021178d81bdee316772afe89cb8bcc6a3e 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,8 +43,8 @@ void test__f_utf_map_multiss_append__works(void **state) {
       status = f_utf_string_dynamic_append(test_names[source.used], &source.array[source.used].name);
 
       assert_int_equal(status, F_none);
-      assert_string_equal(source.array[source.used].name.string, test_names[source.used].string);
-      assert_int_equal(source.array[source.used].name.used, test_names[source.used].used);
+      assert_string_equal((const char * const) source.array[source.used].name.string, (const char * const) test_names[source.used].string);
+      assert_int_equal((const char * const) source.array[source.used].name.used, (const char * const) 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_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_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].name.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].name.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 a729aec6b3d0f9e938468bd3d8d07b5a181e59c8..f730d9a35ce7fc9ea5d1ddba67334e668a48efc4 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_map_multiss_append_all__works(void **state) {
 
         assert_int_equal(status, F_none);
         assert_int_equal(source.array[source.used].array[i].name.used, test_names[i].used);
-        assert_string_equal(source.array[source.used].array[i].name.string, test_names[i].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].name.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_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_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].name.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].name.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 de5ca2b2c0862f2ea9d69c8ad9550c76da9ba0e7..5ab396bceb88db70f1e6ffd6625678d7a1b787d6 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_maps_append__works(void **state) {
     f_status_t status = f_utf_string_dynamic_append(test_name, &source.name);
 
     assert_int_equal(status, F_none);
-    assert_string_equal(source.name.string, test_name.string);
+    assert_string_equal((const char * const) source.name.string, (const char * const) test_name.string);
     assert_int_equal(source.name.used, test_name.used);
 
     status = f_utf_string_dynamic_append(test_value, &source.value);
 
     assert_int_equal(status, F_none);
-    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_maps_append__works(void **state) {
     assert_int_equal(destination.used, 1);
     assert_int_equal(destination.array[0].name.used, source.name.used);
     assert_int_equal(destination.array[0].value.used, source.value.used);
-    assert_string_equal(destination.array[0].name.string, source.name.string);
-    assert_string_equal(destination.array[0].value.string, source.value.string);
+    assert_string_equal((const char * const) destination.array[0].name.string, (const char * const) source.name.string);
+    assert_string_equal((const char * const) destination.array[0].value.string, (const char * const) source.value.string);
   }
 
   free((void *) source.name.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 12ccf8a3a8db4538be1e5a196422d21cf7af122f..c00b1f2c344785520a18d97e1161f86f34fa0270 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_maps_append_all__works(void **state) {
       status = f_utf_string_dynamic_append(test_name, &source.array[source.used].name);
 
       assert_int_equal(status, F_none);
-      assert_string_equal(source.array[source.used].name.string, test_name.string);
+      assert_string_equal((const char * const) source.array[source.used].name.string, (const char * const) test_name.string);
       assert_int_equal(source.array[source.used].name.used, test_name.used);
 
       status = f_utf_string_dynamic_append(test_value, &source.array[source.used].value);
 
       assert_int_equal(status, F_none);
-      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_maps_append_all__works(void **state) {
       assert_int_equal(destination.array[i].name.used, source.array[i].name.used);
       assert_int_equal(destination.array[i].value.used, source.array[i].value.used);
 
-      assert_string_equal(destination.array[i].name.string, source.array[i].name.string);
-      assert_string_equal(destination.array[i].value.string, source.array[i].value.string);
+      assert_string_equal((const char * const) destination.array[i].name.string, (const char * const) source.array[i].name.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 6b7eb4124a5a81d91c50c07dd95f8ed9a017dfcd..b6ec3432284a4fe0afc5e2aba626091ab7f6b750 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,14 +32,14 @@ void test__f_utf_mapss_append__works(void **state) {
       status = f_utf_string_dynamic_append(test_names[source.used], &source.array[source.used].name);
 
       assert_int_equal(status, F_none);
-      assert_string_equal(source.array[source.used].name.string, test_names[source.used].string);
-      assert_int_equal(source.array[source.used].name.used, test_names[source.used].used);
+      assert_string_equal((const char * const) source.array[source.used].name.string, (const char * const) test_names[source.used].string);
+      assert_int_equal((const char * const) source.array[source.used].name.used, (const char * const) 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_none);
-      assert_string_equal(source.array[source.used].value.string, test_values[source.used].string);
-      assert_int_equal(source.array[source.used].value.used, test_values[source.used].used);
+      assert_string_equal((const char * const) source.array[source.used].value.string, (const char * const) test_values[source.used].string);
+      assert_int_equal((const char * const) source.array[source.used].value.used, (const char * const) test_values[source.used].used);
     } // for
   }
 
@@ -54,8 +54,8 @@ void test__f_utf_mapss_append__works(void **state) {
       assert_int_equal(destination.array[0].array[i].name.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].name.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].name.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 f7f1e110411fbcfa61bee169ec34cf1858920523..fe38257762ef7980aaeb2f8b87234bedc4abad47 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_mapss_append_all__works(void **state) {
         status = f_utf_string_dynamic_append(test_names[i], &source.array[source.used].array[i].name);
 
         assert_int_equal(status, F_none);
-        assert_string_equal(source.array[source.used].array[i].name.string, test_names[i].string);
+        assert_string_equal((const char * const) source.array[source.used].array[i].name.string, (const char * const) test_names[i].string);
         assert_int_equal(source.array[source.used].array[i].name.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_none);
-        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_mapss_append_all__works(void **state) {
         assert_int_equal(destination.array[j].array[i].name.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].name.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].name.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 ead9e962a0ad4ba4718658003cbfcbd4abb7d1cd..d9436d4bde29b715e840e2bcb2a8fb1cdf6e06ee 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_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 663e2400fd17fc153c78c1840de6c3b462cdaffc..c525d2276884df6c339108ae6411310ba6d6aeff 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_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 92ebbf137d1c05a79387377dcd83c05daae2f18c..bb1a7330db62e87cb7be754ad96307d1c37929d8 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_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 8d8cb24764315a4452143e1902a45474033b3260..fd484fd8f8f38cf6a90fd03957ffb5a5f8c17daf 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_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
   }