Add tests

Author: Brooooooklyn

.github/workflows/CI.yml

@@ -8,6 +8,29 @@ on:
       - main
 
 jobs:
+  test:
+    strategy:
+      matrix:
+        settings:
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu-latest
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
+          - target: aarch64-unknown-linux-gnu
+            os: ubuntu-24.04-arm
+          - target: aarch64-apple-darwin
+            os: macos-latest
+      fail-fast: false
+    runs-on: ${{ matrix.settings.os }}
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.settings.target }}
+      - name: Run benchmarks
+        run: cargo test
+
   bench:
     strategy:
       matrix:

src/lib.rs

@@ -1,8 +1,5 @@
 #![cfg_attr(feature = "nightly", feature(test))]
 
-#[cfg(target_arch = "x86_64")]
-pub use x86::encode_str;
-
 #[cfg(target_arch = "x86_64")]
 mod x86;
 
@@ -134,8 +131,20 @@ pub fn encode_str_fallback<S: AsRef<str>>(input: S) -> String {
     unsafe { String::from_utf8_unchecked(result) }
 }
 
-#[cfg(not(target_arch = "x86_64"))]
+/// Main entry point for JSON string escaping with SIMD acceleration
+#[inline]
 pub fn encode_str<S: AsRef<str>>(input: S) -> String {
+    #[cfg(target_arch = "x86_64")]
+    {
+        // Runtime CPU feature detection for x86_64
+        if is_x86_feature_detected!("avx2") {
+            unsafe { return x86::encode_str_avx2(input) }
+        } else if is_x86_feature_detected!("sse2") {
+            unsafe { return x86::encode_str_sse2(input) }
+        }
+    }
+
+    // Fallback to optimized scalar implementation
     encode_str_fallback(input)
 }
 
@@ -170,3 +179,165 @@ fn test_escape_json_string() {
         fixture
     );
 }
+
+// Test cases for various string sizes to cover different SIMD paths
+
+#[test]
+fn test_empty_string() {
+    assert_eq!(encode_str(""), r#""""#);
+}
+
+#[test]
+fn test_very_small_strings() {
+    // Less than 16 bytes (SSE register size)
+    assert_eq!(encode_str("a"), r#""a""#);
+    assert_eq!(encode_str("ab"), r#""ab""#);
+    assert_eq!(encode_str("hello"), r#""hello""#);
+    assert_eq!(encode_str("hello\n"), r#""hello\n""#);
+    assert_eq!(encode_str("\""), r#""\"""#);
+    assert_eq!(encode_str("\\"), r#""\\""#);
+    assert_eq!(encode_str("\t"), r#""\t""#);
+    assert_eq!(encode_str("\r\n"), r#""\r\n""#);
+}
+
+#[test]
+fn test_small_strings_16_bytes() {
+    // Exactly 16 bytes - SSE register boundary
+    let s16 = "0123456789abcdef";
+    assert_eq!(s16.len(), 16);
+    assert_eq!(encode_str(s16), serde_json::to_string(s16).unwrap());
+
+    // 16 bytes with escapes
+    let s16_esc = "01234567\t9abcde";
+    assert_eq!(s16_esc.len(), 15); // \t is 1 byte
+    assert_eq!(encode_str(s16_esc), serde_json::to_string(s16_esc).unwrap());
+}
+
+#[test]
+fn test_medium_strings_32_bytes() {
+    // Exactly 32 bytes - AVX2 register boundary
+    let s32 = "0123456789abcdef0123456789abcdef";
+    assert_eq!(s32.len(), 32);
+    assert_eq!(encode_str(s32), serde_json::to_string(s32).unwrap());
+
+    // 32 bytes with escapes at different positions
+    let s32_esc = "0123456789abcde\"0123456789abcde";
+    assert_eq!(encode_str(s32_esc), serde_json::to_string(s32_esc).unwrap());
+}
+
+#[test]
+fn test_large_strings_128_bytes() {
+    // Exactly 128 bytes - main loop size
+    let s128 = "0123456789abcdef".repeat(8);
+    assert_eq!(s128.len(), 128);
+    assert_eq!(encode_str(&s128), serde_json::to_string(&s128).unwrap());
+
+    // 128 bytes with escapes spread throughout
+    let mut s128_esc = String::new();
+    for i in 0..8 {
+        if i % 2 == 0 {
+            s128_esc.push_str("0123456789abcd\n");
+        } else {
+            s128_esc.push_str("0123456789abcd\"");
+        }
+    }
+    assert_eq!(encode_str(&s128_esc), serde_json::to_string(&s128_esc).unwrap());
+}
+
+#[test]
+fn test_unaligned_data() {
+    // Test strings that start at various alignments
+    for offset in 0..32 {
+        let padding = " ".repeat(offset);
+        let test_str = format!("{}{}", padding, "test\nstring\"with\\escapes");
+        let result = encode_str(&test_str[offset..]);
+        let expected = serde_json::to_string(&test_str[offset..]).unwrap();
+        assert_eq!(result, expected, "Failed at offset {}", offset);
+    }
+}
+
+#[test]
+fn test_sparse_escapes() {
+    // Large string with escapes only at the beginning and end
+    let mut s = String::new();
+    s.push('"');
+    s.push_str(&"a".repeat(500));
+    s.push('\\');
+    assert_eq!(encode_str(&s), serde_json::to_string(&s).unwrap());
+}
+
+#[test]
+fn test_dense_escapes() {
+    // String with many escapes
+    let s = "\"\\\"\\\"\\\"\\".repeat(50);
+    assert_eq!(encode_str(&s), serde_json::to_string(&s).unwrap());
+
+    // All control characters
+    let mut ctrl = String::new();
+    for _ in 0..10 {
+        for i in 0u8..32 {
+            ctrl.push(i as char);
+        }
+    }
+    assert_eq!(encode_str(&ctrl), serde_json::to_string(&ctrl).unwrap());
+}
+
+#[test]
+fn test_boundary_conditions() {
+    // Test around 256 byte boundary (common cache line multiple)
+    for size in 250..260 {
+        let s = "a".repeat(size);
+        assert_eq!(encode_str(&s), serde_json::to_string(&s).unwrap());
+
+        // With escape at the end
+        let mut s_esc = "a".repeat(size - 1);
+        s_esc.push('"');
+        assert_eq!(encode_str(&s_esc), serde_json::to_string(&s_esc).unwrap());
+    }
+}
+
+#[test]
+fn test_all_escape_types() {
+    // Test each escape type individually
+    assert_eq!(encode_str("\x00"), r#""\u0000""#);
+    assert_eq!(encode_str("\x08"), r#""\b""#);
+    assert_eq!(encode_str("\x09"), r#""\t""#);
+    assert_eq!(encode_str("\x0A"), r#""\n""#);
+    assert_eq!(encode_str("\x0C"), r#""\f""#);
+    assert_eq!(encode_str("\x0D"), r#""\r""#);
+    assert_eq!(encode_str("\x1F"), r#""\u001f""#);
+    assert_eq!(encode_str("\""), r#""\"""#);
+    assert_eq!(encode_str("\\"), r#""\\""#);
+
+    // Test all control characters
+    for i in 0u8..32 {
+        let s = String::from_utf8(vec![i]).unwrap();
+        let result = encode_str(&s);
+        let expected = serde_json::to_string(&s).unwrap();
+        assert_eq!(result, expected, "Failed for byte 0x{:02x}", i);
+    }
+}
+
+#[test]
+fn test_mixed_content() {
+    // Mix of ASCII, escapes, and multi-byte UTF-8
+    let mixed = r#"Hello "World"!
+    Tab:	Here
+    Emoji: 😀 Chinese: 中文
+    Math: ∑∫∂ Music: 𝄞
+    Escape: \" \\ \n \r \t"#;
+    assert_eq!(encode_str(mixed), serde_json::to_string(mixed).unwrap());
+}
+
+#[test]
+fn test_repeated_patterns() {
+    // Patterns that might benefit from or confuse SIMD operations
+    let pattern1 = "abcd".repeat(100);
+    assert_eq!(encode_str(&pattern1), serde_json::to_string(&pattern1).unwrap());
+
+    let pattern2 = "a\"b\"".repeat(100);
+    assert_eq!(encode_str(&pattern2), serde_json::to_string(&pattern2).unwrap());
+
+    let pattern3 = "\t\n".repeat(100);
+    assert_eq!(encode_str(&pattern3), serde_json::to_string(&pattern3).unwrap());
+}

src/x86.rs

@@ -448,16 +448,3 @@ fn write_escape(result: &mut Vec<u8>, escape_byte: u8, c: u8) {
     }
 }
 
-// Public entry point that does runtime CPU detection
-#[inline]
-pub fn encode_str<S: AsRef<str>>(input: S) -> String {
-    // Runtime CPU feature detection
-    if is_x86_feature_detected!("avx2") {
-        unsafe { encode_str_avx2(input) }
-    } else if is_x86_feature_detected!("sse2") {
-        unsafe { encode_str_sse2(input) }
-    } else {
-        // Fallback to scalar implementation
-        crate::encode_str_fallback(input)
-    }
-}