refactor: make unicode_data tests normal tests

Instead of generating a standalone executable to test `unicode_data`,
generate normal tests in `coretests`. This ensures tests are always
generated, and will be run as part of the normal testsuite.

Also change the generated tests to loop over lookup tables, rather than
generating a separate `assert_eq!()` statement for every codepoint. The
old approach produced a massive (20,000 lines plus) file which took
minutes to compile!

Author: Kmeakin

library/core/src/unicode/mod.rs

@@ -20,7 +20,7 @@ pub(crate) mod printable;
 
 mod rt;
 #[allow(unreachable_pub)]
-mod unicode_data;
+pub mod unicode_data;
 
 /// The version of [Unicode](https://www.unicode.org/) that the Unicode parts of
 /// `char` and `str` methods are based on.

library/coretests/tests/lib.rs

@@ -111,6 +111,7 @@
 #![feature(try_find)]
 #![feature(try_trait_v2)]
 #![feature(uint_bit_width)]
+#![feature(unicode_internals)]
 #![feature(unsize)]
 #![feature(unwrap_infallible)]
 // tidy-alphabetical-end

library/coretests/tests/unicode.rs

@@ -1,5 +1,205 @@
+use core::unicode::unicode_data;
+
+mod test_data;
+
 #[test]
 pub fn version() {
     let (major, _minor, _update) = core::char::UNICODE_VERSION;
     assert!(major >= 10);
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn alphabetic_true() {
+    for range in test_data::ALPHABETIC_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::alphabetic::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn alphabetic_false() {
+    for range in test_data::ALPHABETIC_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::alphabetic::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn case_ignorable_true() {
+    for range in test_data::CASE_IGNORABLE_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::case_ignorable::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn case_ignorable_false() {
+    for range in test_data::CASE_IGNORABLE_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::case_ignorable::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn cased_true() {
+    for range in test_data::CASED_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::cased::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn cased_false() {
+    for range in test_data::CASED_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::cased::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn grapheme_extend_true() {
+    for range in test_data::GRAPHEME_EXTEND_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::grapheme_extend::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn grapheme_extend_false() {
+    for range in test_data::GRAPHEME_EXTEND_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::grapheme_extend::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn lowercase_true() {
+    for range in test_data::LOWERCASE_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::lowercase::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn lowercase_false() {
+    for range in test_data::LOWERCASE_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::lowercase::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn n_true() {
+    for range in test_data::N_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::n::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn n_false() {
+    for range in test_data::N_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::n::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn uppercase_true() {
+    for range in test_data::UPPERCASE_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::uppercase::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn uppercase_false() {
+    for range in test_data::UPPERCASE_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::uppercase::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn white_space_true() {
+    for range in test_data::WHITE_SPACE_TRUE {
+        for c in range.clone() {
+            assert!(unicode_data::white_space::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn white_space_false() {
+    for range in test_data::WHITE_SPACE_FALSE {
+        for c in range.clone() {
+            assert!(!unicode_data::white_space::lookup(c), "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn to_lower_mapped() {
+    for (c, chars) in test_data::TO_LOWER_MAPPED {
+        assert_eq!(unicode_data::conversions::to_lower(*c), *chars, "{c:?}");
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn to_lower_unmapped() {
+    for range in test_data::TO_LOWER_UNMAPPED {
+        for c in range.clone() {
+            assert_eq!(unicode_data::conversions::to_lower(c), [c, '\0', '\0'], "{c:?}");
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn to_upper_mapped() {
+    for (c, chars) in test_data::TO_UPPER_MAPPED {
+        assert_eq!(unicode_data::conversions::to_upper(*c), *chars, "{c:?}");
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn to_upper_unmapped() {
+    for range in test_data::TO_UPPER_UNMAPPED {
+        for c in range.clone() {
+            assert_eq!(unicode_data::conversions::to_upper(c), [c, '\0', '\0'], "{c:?}");
+        }
+    }
+}