bool -> void where possible, fix more comments

smallp-o-p · smallp-o-p · commit 3ce357f6fcf1 · 2025-11-13T20:48:49.000-05:00
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.ctor/default.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.ctor/default.pass.cpp
@@ -10,8 +10,6 @@
 
 // <text_encoding>
 
-// struct text_encoding
-
 // text_encoding::text_encoding() noexcept
 
 #include <cassert>
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.ctor/id.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.ctor/id.pass.cpp
@@ -22,24 +22,21 @@
 
 using id = std::text_encoding::id;
 
-constexpr bool id_ctor(id i, id expect_id, std::string_view expect_name) {
+constexpr void id_ctor(id i, id expect_id, std::string_view expect_name) {
   std::text_encoding te = std::text_encoding(i);
 
   assert(te.mib() == expect_id);
   assert(expect_name == te.name());
   assert(std::ranges::contains(te.aliases(), expect_name));
-
-  return true;
 }
 
-constexpr bool id_ctors() {
+constexpr void id_ctors() {
   for (auto pair : unique_encoding_data) {
-    assert(id_ctor(id(pair.mib), id(pair.mib), pair.name));
+    id_ctor(id(pair.mib), id(pair.mib), pair.name);
   }
-  return true;
 }
 
-constexpr bool test_unknown_other() {
+constexpr void test_unknown_other() {
   {
     std::text_encoding te = std::text_encoding(id::other);
 
@@ -55,18 +52,17 @@ constexpr bool test_unknown_other() {
     assert(std::string_view("") == te.name());
     assert(std::ranges::empty(te.aliases()));
   }
-  return true;
 }
 
 constexpr bool tests() {
   {
     // 2. Constructing an object with a valid id must set mib() and the name to the corresponding value.
-    assert(id_ctors());
+    id_ctors();
   }
 
   {
     // 3. Constructing an object using id::unknown or id::other must set mib() to id::unknown or id::other, respectively, and the name to an empty string.
-    assert(test_unknown_other());
+    test_unknown_other();
   }
 
   return true;
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.ctor/string_view.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.ctor/string_view.pass.cpp
@@ -21,68 +21,63 @@
 
 #include "../test_text_encoding.h"
 
-constexpr bool test_ctor(std::string_view str, std::string_view expect, std::text_encoding::id expect_id) {
+constexpr void test_ctor(std::string_view str, std::string_view expect, std::text_encoding::id expect_id) {
   std::text_encoding te = std::text_encoding(str);
-  bool success = true;
 
   assert(te.mib() == expect_id);
   assert(te.name() == expect);
-
-  return success;
 }
 
-constexpr bool test_primary_encoding_spellings() {
+constexpr void test_primary_encoding_spellings() {
   for (auto& data : unique_encoding_data) {
     std::text_encoding te = std::text_encoding(data.name);
 
     assert(te.mib() == std::text_encoding::id(data.mib));
     assert(te.name() == data.name);
   }
-  return true;
 }
 
-constexpr bool test_others() {
+constexpr void test_others() {
   for (auto& name : other_names) {
     std::text_encoding te = std::text_encoding(name);
 
     assert(te.mib() == std::text_encoding::other);
     assert(te.name() == name);
   }
-  return true;
 }
 
 constexpr bool tests() {
   // happy paths
   {
-    assert(test_primary_encoding_spellings());
+    test_primary_encoding_spellings();
   }
 
   {
-    assert(test_ctor("U_T_F-8", "U_T_F-8", std::text_encoding::UTF8));
+    test_ctor("U_T_F-8", "U_T_F-8", std::text_encoding::UTF8);
   }
 
   {
-    assert(test_ctor("utf8", "utf8", std::text_encoding::UTF8));
+    test_ctor("utf8", "utf8", std::text_encoding::UTF8);
   }
 
   {
-    assert(test_ctor("u.t.f-008", "u.t.f-008", std::text_encoding::UTF8));
+    test_ctor("u.t.f-008", "u.t.f-008", std::text_encoding::UTF8);
   }
 
   {
-    assert(test_ctor("utf-80", "utf-80", std::text_encoding::other));
+    test_ctor("utf-80", "utf-80", std::text_encoding::other);
   }
 
   {
-    assert(test_ctor("iso885931988", "iso885931988", std::text_encoding::ISOLatin3));
+    test_ctor("iso885931988", "iso885931988", std::text_encoding::ISOLatin3);
   }
 
   {
-    assert(test_ctor("iso00885931988", "iso00885931988", std::text_encoding::ISOLatin3));
+    test_ctor("iso00885931988", "iso00885931988", std::text_encoding::ISOLatin3);
   }
 
   {
-    assert(test_others());
+    test_others();
   }
 
   return true;
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.eq/equal.id.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.eq/equal.id.pass.cpp
@@ -10,7 +10,7 @@
 
 // <text_encoding>
 
-// text_encoding operator==(const text_encoding&, id) noexcept
+// bool text_encoding::operator==(const text_encoding&, id) noexcept
 
 #include <cassert>
 #include <text_encoding>
@@ -20,13 +20,11 @@
 
 using id = std::text_encoding::id;
 
-constexpr bool test_primary_encodings() {
+constexpr void test_primary_encodings() {
   for (auto& data : unique_encoding_data) {
     std::text_encoding te = std::text_encoding(id(data.mib));
     assert(te == id(data.mib));
   }
-
-  return true;
 }
 
 constexpr bool tests() {
@@ -62,16 +60,15 @@ constexpr bool tests() {
   }
 
   {
-    assert(test_primary_encodings());
+    test_primary_encodings();
   }
 
   return true;
 }
 
 int main(int, char**) {
-  {
-    static_assert(tests());
-    assert(tests());
-  }
+  tests();
+  static_assert(tests());
+
   return 0;
 }
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.eq/equal.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.eq/equal.pass.cpp
@@ -10,7 +10,7 @@
 
 // <text_encoding>
 
-// text_encoding operator==(const text_encoding&, const text_encoding&) noexcept
+// bool text_encoding::operator==(const text_encoding&, const text_encoding&) noexcept
 
 #include <cassert>
 #include <text_encoding>
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.hash/hash.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.hash/hash.pass.cpp
@@ -17,7 +17,7 @@
 #include <text_encoding>
 #include <type_traits>
 
-bool test_te_hash() {
+void test_te_hash() {
   using T = std::text_encoding;
   using H = std::hash<T>;
 
@@ -49,8 +49,6 @@ bool test_te_hash() {
     const H h{};
     assert(h(te1) == h(te2));
   }
-
-  return true;
 }
 
 int main(int, char**) {
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.members/aliases.compile.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.members/aliases.compile.pass.cpp
@@ -10,7 +10,7 @@
 
 // <text_encoding>
 
-// text_encoding text_encoding::aliases();
+// text_encoding::aliases_view;
 
 #include <concepts>
 #include <text_encoding>
diff --git a/libcxx/test/std/utilities/text_encoding/text_encoding.members/text_encoding.aliases_view/empty.pass.cpp b/libcxx/test/std/utilities/text_encoding/text_encoding.members/text_encoding.aliases_view/empty.pass.cpp
@@ -21,7 +21,7 @@
 
 using id = std::text_encoding::id;
 
-constexpr bool test_other_unknown() {
+constexpr void test_other_unknown() {
   {
     std::text_encoding te_other = std::text_encoding(id::other);
 
@@ -40,11 +40,9 @@ constexpr bool test_other_unknown() {
     assert(unknown_range.empty());
     assert(!bool(unknown_range));
   }
-
-  return true;
 }
 
-constexpr bool test_primary_encodings() {
+constexpr void test_primary_encodings() {
   for (auto& data : unique_encoding_data) {
     std::text_encoding te = std::text_encoding(id(data.mib));
 
@@ -54,18 +52,17 @@ constexpr bool test_primary_encodings() {
     assert(!range.empty());
     assert(bool(range));
   }
-  return true;
 }
 
 constexpr bool tests() {
   // 1. An alias_view of a text_encoding object for "other" and "unknown" are empty
   {
-    assert(test_other_unknown());
+    test_other_unknown();
   }
 
   // 2. An alias_view of a text_encoding object for a known encoding e.g. "UTF-8" is not empty
   {
-    assert(test_primary_encodings());
+    test_primary_encodings();
   }
 
   return true;

Original file line number	Diff line number	Diff line change
`@@ -22,24 +22,21 @@`
`22`	`22`
`23`	`23`	`using id = std::text_encoding::id;`
`24`	`24`
`25`		`-constexpr bool id_ctor(id i, id expect_id, std::string_view expect_name) {`
	`25`	`+constexpr void id_ctor(id i, id expect_id, std::string_view expect_name) {`
`26`	`26`	`std::text_encoding te = std::text_encoding(i);`
`27`	`27`
`28`	`28`	`assert(te.mib() == expect_id);`
`29`	`29`	`assert(expect_name == te.name());`
`30`	`30`	`assert(std::ranges::contains(te.aliases(), expect_name));`
`31`		`-`
`32`		`- return true;`
`33`	`31`	`}`
`34`	`32`
`35`		`-constexpr bool id_ctors() {`
	`33`	`+constexpr void id_ctors() {`
`36`	`34`	`for (auto pair : unique_encoding_data) {`
`37`		`- assert(id_ctor(id(pair.mib), id(pair.mib), pair.name));`
	`35`	`+ id_ctor(id(pair.mib), id(pair.mib), pair.name);`
`38`	`36`	`}`
`39`		`- return true;`
`40`	`37`	`}`
`41`	`38`
`42`		`-constexpr bool test_unknown_other() {`
	`39`	`+constexpr void test_unknown_other() {`
`43`	`40`	`{`
`44`	`41`	`std::text_encoding te = std::text_encoding(id::other);`
`45`	`42`
`@@ -55,18 +52,17 @@ constexpr bool test_unknown_other() {`
`55`	`52`	`assert(std::string_view("") == te.name());`
`56`	`53`	`assert(std::ranges::empty(te.aliases()));`
`57`	`54`	`}`
`58`		`- return true;`
`59`	`55`	`}`
`60`	`56`
`61`	`57`	`constexpr bool tests() {`
`62`	`58`	`{`
`63`	`59`	`// 2. Constructing an object with a valid id must set mib() and the name to the corresponding value.`
`64`		`- assert(id_ctors());`
	`60`	`+ id_ctors();`
`65`	`61`	`}`
`66`	`62`
`67`	`63`	`{`
`68`	`64`	`// 3. Constructing an object using id::unknown or id::other must set mib() to id::unknown or id::other, respectively, and the name to an empty string.`
`69`		`- assert(test_unknown_other());`
	`65`	`+ test_unknown_other();`
`70`	`66`	`}`
`71`	`67`
`72`	`68`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -21,68 +21,63 @@`
`21`	`21`
`22`	`22`	`#include "../test_text_encoding.h"`
`23`	`23`
`24`		`-constexpr bool test_ctor(std::string_view str, std::string_view expect, std::text_encoding::id expect_id) {`
	`24`	`+constexpr void test_ctor(std::string_view str, std::string_view expect, std::text_encoding::id expect_id) {`
`25`	`25`	`std::text_encoding te = std::text_encoding(str);`
`26`		`- bool success = true;`
`27`	`26`
`28`	`27`	`assert(te.mib() == expect_id);`
`29`	`28`	`assert(te.name() == expect);`
`30`		`-`
`31`		`- return success;`
`32`	`29`	`}`
`33`	`30`
`34`		`-constexpr bool test_primary_encoding_spellings() {`
	`31`	`+constexpr void test_primary_encoding_spellings() {`
`35`	`32`	`for (auto& data : unique_encoding_data) {`
`36`	`33`	`std::text_encoding te = std::text_encoding(data.name);`
`37`	`34`
`38`	`35`	`assert(te.mib() == std::text_encoding::id(data.mib));`
`39`	`36`	`assert(te.name() == data.name);`
`40`	`37`	`}`
`41`		`- return true;`
`42`	`38`	`}`
`43`	`39`
`44`		`-constexpr bool test_others() {`
	`40`	`+constexpr void test_others() {`
`45`	`41`	`for (auto& name : other_names) {`
`46`	`42`	`std::text_encoding te = std::text_encoding(name);`
`47`	`43`
`48`	`44`	`assert(te.mib() == std::text_encoding::other);`
`49`	`45`	`assert(te.name() == name);`
`50`	`46`	`}`
`51`		`- return true;`
`52`	`47`	`}`
`53`	`48`
`54`	`49`	`constexpr bool tests() {`
`55`	`50`	`// happy paths`
`56`	`51`	`{`
`57`		`- assert(test_primary_encoding_spellings());`
	`52`	`+ test_primary_encoding_spellings();`
`58`	`53`	`}`
`59`	`54`
`60`	`55`	`{`
`61`		`- assert(test_ctor("U_T_F-8", "U_T_F-8", std::text_encoding::UTF8));`
	`56`	`+ test_ctor("U_T_F-8", "U_T_F-8", std::text_encoding::UTF8);`
`62`	`57`	`}`
`63`	`58`
`64`	`59`	`{`
`65`		`- assert(test_ctor("utf8", "utf8", std::text_encoding::UTF8));`
	`60`	`+ test_ctor("utf8", "utf8", std::text_encoding::UTF8);`
`66`	`61`	`}`
`67`	`62`
`68`	`63`	`{`
`69`		`- assert(test_ctor("u.t.f-008", "u.t.f-008", std::text_encoding::UTF8));`
	`64`	`+ test_ctor("u.t.f-008", "u.t.f-008", std::text_encoding::UTF8);`
`70`	`65`	`}`
`71`	`66`
`72`	`67`	`{`
`73`		`- assert(test_ctor("utf-80", "utf-80", std::text_encoding::other));`
	`68`	`+ test_ctor("utf-80", "utf-80", std::text_encoding::other);`
`74`	`69`	`}`
`75`	`70`
`76`	`71`	`{`
`77`		`- assert(test_ctor("iso885931988", "iso885931988", std::text_encoding::ISOLatin3));`
	`72`	`+ test_ctor("iso885931988", "iso885931988", std::text_encoding::ISOLatin3);`
`78`	`73`	`}`
`79`	`74`
`80`	`75`	`{`
`81`		`- assert(test_ctor("iso00885931988", "iso00885931988", std::text_encoding::ISOLatin3));`
	`76`	`+ test_ctor("iso00885931988", "iso00885931988", std::text_encoding::ISOLatin3);`
`82`	`77`	`}`
`83`	`78`
`84`	`79`	`{`
`85`		`- assert(test_others());`
	`80`	`+ test_others();`
`86`	`81`	`}`
`87`	`82`
`88`	`83`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`// <text_encoding>`
`12`	`12`
`13`		`-// text_encoding operator==(const text_encoding&, id) noexcept`
	`13`	`+// bool text_encoding::operator==(const text_encoding&, id) noexcept`
`14`	`14`
`15`	`15`	`#include <cassert>`
`16`	`16`	`#include <text_encoding>`
`@@ -20,13 +20,11 @@`
`20`	`20`
`21`	`21`	`using id = std::text_encoding::id;`
`22`	`22`
`23`		`-constexpr bool test_primary_encodings() {`
	`23`	`+constexpr void test_primary_encodings() {`
`24`	`24`	`for (auto& data : unique_encoding_data) {`
`25`	`25`	`std::text_encoding te = std::text_encoding(id(data.mib));`
`26`	`26`	`assert(te == id(data.mib));`
`27`	`27`	`}`
`28`		`-`
`29`		`- return true;`
`30`	`28`	`}`
`31`	`29`
`32`	`30`	`constexpr bool tests() {`
`@@ -62,16 +60,15 @@ constexpr bool tests() {`
`62`	`60`	`}`
`63`	`61`
`64`	`62`	`{`
`65`		`- assert(test_primary_encodings());`
	`63`	`+ test_primary_encodings();`
`66`	`64`	`}`
`67`	`65`
`68`	`66`	`return true;`
`69`	`67`	`}`
`70`	`68`
`71`	`69`	`int main(int, char**) {`
`72`		`- {`
`73`		`- static_assert(tests());`
`74`		`- assert(tests());`
`75`		`- }`
	`70`	`+ tests();`
	`71`	`+ static_assert(tests());`
	`72`	`+`
`76`	`73`	`return 0;`
`77`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`#include <text_encoding>`
`18`	`18`	`#include <type_traits>`
`19`	`19`
`20`		`-bool test_te_hash() {`
	`20`	`+void test_te_hash() {`
`21`	`21`	`using T = std::text_encoding;`
`22`	`22`	`using H = std::hash<T>;`
`23`	`23`
`@@ -49,8 +49,6 @@ bool test_te_hash() {`
`49`	`49`	`const H h{};`
`50`	`50`	`assert(h(te1) == h(te2));`
`51`	`51`	`}`
`52`		`-`
`53`		`- return true;`
`54`	`52`	`}`
`55`	`53`
`56`	`54`	`int main(int, char**) {`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`
`22`	`22`	`using id = std::text_encoding::id;`
`23`	`23`
`24`		`-constexpr bool test_other_unknown() {`
	`24`	`+constexpr void test_other_unknown() {`
`25`	`25`	`{`
`26`	`26`	`std::text_encoding te_other = std::text_encoding(id::other);`
`27`	`27`
`@@ -40,11 +40,9 @@ constexpr bool test_other_unknown() {`
`40`	`40`	`assert(unknown_range.empty());`
`41`	`41`	`assert(!bool(unknown_range));`
`42`	`42`	`}`
`43`		`-`
`44`		`- return true;`
`45`	`43`	`}`
`46`	`44`
`47`		`-constexpr bool test_primary_encodings() {`
	`45`	`+constexpr void test_primary_encodings() {`
`48`	`46`	`for (auto& data : unique_encoding_data) {`
`49`	`47`	`std::text_encoding te = std::text_encoding(id(data.mib));`
`50`	`48`
`@@ -54,18 +52,17 @@ constexpr bool test_primary_encodings() {`
`54`	`52`	`assert(!range.empty());`
`55`	`53`	`assert(bool(range));`
`56`	`54`	`}`
`57`		`- return true;`
`58`	`55`	`}`
`59`	`56`
`60`	`57`	`constexpr bool tests() {`
`61`	`58`	`// 1. An alias_view of a text_encoding object for "other" and "unknown" are empty`
`62`	`59`	`{`
`63`		`- assert(test_other_unknown());`
	`60`	`+ test_other_unknown();`
`64`	`61`	`}`
`65`	`62`
`66`	`63`	`// 2. An alias_view of a text_encoding object for a known encoding e.g. "UTF-8" is not empty`
`67`	`64`	`{`
`68`		`- assert(test_primary_encodings());`
	`65`	`+ test_primary_encodings();`
`69`	`66`	`}`
`70`	`67`
`71`	`68`	`return true;`