Add exhaustive tests for next_code_point and next_code_point_reverse

There are only 0x10FFFF possible codepoints, so we can exhaustively test
all of them.

Author: Kmeakin

library/alloctests/tests/lib.rs

@@ -25,6 +25,8 @@
 #![feature(round_char_boundary)]
 #![feature(slice_partition_dedup)]
 #![feature(string_from_utf8_lossy_owned)]
+#![feature(str_internals)]
+#![feature(char_internals)]
 #![feature(string_remove_matches)]
 #![feature(const_btree_len)]
 #![feature(const_trait_impl)]

library/alloctests/tests/str.rs

@@ -1156,6 +1156,76 @@ fn test_total_ord() {
     assert_eq!("22".cmp("1234"), Greater);
 }
 
+fn test_next_code_point(iter: impl Iterator<Item = u32>) {
+    for expected in iter {
+        let mut bytes = [0; 4];
+        let mut bytes = std::char::encode_utf8_raw(expected, &mut bytes).iter();
+
+        // SAFETY: `bytes` is UTF8-like
+        let got = unsafe { core::str::next_code_point(&mut bytes) };
+        assert_eq!(got, Some(expected));
+
+        // SAFETY: `bytes` is UTF8-like
+        let got = unsafe { core::str::next_code_point(&mut bytes) };
+        assert_eq!(got, None);
+    }
+}
+
+fn test_next_code_point_reverse(iter: impl Iterator<Item = u32>) {
+    for expected in iter {
+        let mut bytes = [0; 4];
+        let mut bytes = std::char::encode_utf8_raw(expected, &mut bytes).iter();
+
+        // SAFETY: `bytes` is UTF8-like
+        let got = unsafe { core::str::next_code_point_reverse(&mut bytes) };
+        assert_eq!(got, Some(expected));
+
+        // SAFETY: `bytes` is UTF8-like
+        let got = unsafe { core::str::next_code_point_reverse(&mut bytes) };
+        assert_eq!(got, None);
+    }
+}
+
+#[test]
+fn test_next_code_point_1byte() {
+    test_next_code_point(0..0x80);
+}
+
+#[test]
+fn test_next_code_point_2byte() {
+    test_next_code_point(0x80..0x800);
+}
+
+#[test]
+fn test_next_code_point_3byte() {
+    test_next_code_point(0x800..0x10_000);
+}
+
+#[test]
+fn test_next_code_point_4byte() {
+    test_next_code_point(0x010_000..=u32::from(char::MAX));
+}
+
+#[test]
+fn test_next_code_point_reverse_1byte() {
+    test_next_code_point_reverse(0..0x80);
+}
+
+#[test]
+fn test_next_code_point_reverse_2byte() {
+    test_next_code_point_reverse(0x80..0x800);
+}
+
+#[test]
+fn test_next_code_point_reverse_3byte() {
+    test_next_code_point_reverse(0x800..0x10_000);
+}
+
+#[test]
+fn test_next_code_point_reverse_4byte() {
+    test_next_code_point_reverse(0x10_000..=u32::from(char::MAX));
+}
+
 #[test]
 fn test_iterator() {
     let s = "ศไทย中华Việt Nam";

library/core/src/str/mod.rs

@@ -58,7 +58,7 @@ pub use lossy::{Utf8Chunk, Utf8Chunks};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use traits::FromStr;
 #[unstable(feature = "str_internals", issue = "none")]
-pub use validations::{next_code_point, utf8_char_width};
+pub use validations::{next_code_point, next_code_point_reverse, utf8_char_width};
 
 #[inline(never)]
 #[cold]

library/core/src/str/validations.rs

@@ -74,8 +74,9 @@ pub unsafe fn next_code_point<'a, I: Iterator<Item = &'a u8>>(bytes: &mut I) ->
 /// # Safety
 ///
 /// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
+#[unstable(feature = "str_internals", issue = "none")]
 #[inline]
-pub(super) unsafe fn next_code_point_reverse<'a, I>(bytes: &mut I) -> Option<u32>
+pub unsafe fn next_code_point_reverse<'a, I>(bytes: &mut I) -> Option<u32>
 where
     I: DoubleEndedIterator<Item = &'a u8>,
 {