add benchmark functions

Author: hkBst

src/lib.rs

@@ -1,3 +1,5 @@
+#![feature(test)]
+
 //! Utilities for validating string and char literals and turning them into
 //! values they represent.
 
@@ -109,6 +111,7 @@ where
 
 /// Used for mixed utf8 string literals, i.e. those that allow both unicode
 /// chars and high bytes.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum MixedUnit {
     /// Used for ASCII chars (written directly or via `\x00`..`\x7f` escapes)
     /// and Unicode chars (written directly or via `\u` escapes).

src/tests.rs

@@ -314,3 +314,5 @@ fn test_unescape_raw_byte_str() {
         ],
     );
 }
+
+mod benches;

src/tests/benches.rs

@@ -0,0 +1,163 @@
+extern crate test;
+
+use super::*;
+use std::iter::{once, repeat_n};
+
+const LEN: usize = 10_000;
+
+#[bench]
+fn bench_skip_ascii_whitespace(b: &mut test::Bencher) {
+    let input: String = test::black_box(repeat_n('\n', LEN - 1).chain(once(' ')).collect());
+    assert_eq!(input.len(), LEN);
+    assert!(input.contains('\n'));
+    b.iter(|| {
+        let mut output = vec![];
+        skip_ascii_whitespace(&mut input.chars(), 0, &mut |range, res| {
+            output.push((range, res))
+        });
+        assert_eq!(
+            output,
+            [((0..LEN + 1), EscapeError::MultipleSkippedLinesWarning)]
+        );
+    });
+}
+
+//
+// Check raw
+//
+
+fn bench_check_raw(b: &mut test::Bencher, c: char, mode: Mode) {
+    let input: String = test::black_box(repeat_n(c, LEN).collect());
+    assert_eq!(input.len(), LEN * c.len_utf8());
+    b.iter(|| {
+        let mut output = vec![];
+        unescape_unicode(&input, mode, &mut |range, res| output.push((range, res)));
+        assert_eq!(output.len(), LEN);
+        assert_eq!(output[0], ((0..c.len_utf8()), Ok(c)));
+    });
+}
+
+// raw str
+
+#[bench]
+fn bench_check_raw_str_ascii(b: &mut test::Bencher) {
+    bench_check_raw(b, 'a', Mode::RawStr);
+}
+
+#[bench]
+fn bench_check_raw_str_unicode(b: &mut test::Bencher) {
+    bench_check_raw(b, '🦀', Mode::RawStr);
+}
+
+// raw byte str
+
+#[bench]
+fn bench_check_raw_byte_str(b: &mut test::Bencher) {
+    bench_check_raw(b, 'a', Mode::RawByteStr);
+}
+
+// raw C str
+
+#[bench]
+fn bench_check_raw_c_str_ascii(b: &mut test::Bencher) {
+    bench_check_raw(b, 'a', Mode::RawCStr);
+}
+
+#[bench]
+fn bench_check_raw_c_str_unicode(b: &mut test::Bencher) {
+    bench_check_raw(b, '🦀', Mode::RawCStr);
+}
+
+//
+// Unescape
+//
+
+fn bench_unescape(b: &mut test::Bencher, s: &str, mode: Mode, expected: char) {
+    let input: String = test::black_box(repeat_n(s, LEN).collect());
+    assert_eq!(input.len(), LEN * s.len());
+    b.iter(|| {
+        let mut output = vec![];
+        unescape_unicode(&input, mode, &mut |range, res| output.push((range, res)));
+        assert_eq!(output.len(), LEN);
+        assert_eq!(output[0], ((0..s.len()), Ok(expected)));
+    });
+}
+
+// str
+
+#[bench]
+fn bench_unescape_str_trivial(b: &mut test::Bencher) {
+    bench_unescape(b, r"a", Mode::Str, 'a');
+}
+
+#[bench]
+fn bench_unescape_str_ascii(b: &mut test::Bencher) {
+    bench_unescape(b, r"\n", Mode::Str, '\n');
+}
+
+#[bench]
+fn bench_unescape_str_hex(b: &mut test::Bencher) {
+    bench_unescape(b, r"\x22", Mode::Str, '"');
+}
+
+#[bench]
+fn bench_unescape_str_unicode(b: &mut test::Bencher) {
+    bench_unescape(b, r"\u{1f980}", Mode::Str, '🦀');
+}
+
+// byte str
+
+#[bench]
+fn bench_unescape_byte_str_trivial(b: &mut test::Bencher) {
+    bench_unescape(b, r"a", Mode::ByteStr, 'a');
+}
+
+#[bench]
+fn bench_unescape_byte_str_ascii(b: &mut test::Bencher) {
+    bench_unescape(b, r"\n", Mode::ByteStr, b'\n' as char);
+}
+
+#[bench]
+fn bench_unescape_byte_str_hex(b: &mut test::Bencher) {
+    bench_unescape(b, r"\xff", Mode::ByteStr, b'\xff' as char);
+}
+
+// C str
+
+fn bench_unescape_c_str(b: &mut test::Bencher, s: &str, expected: MixedUnit) {
+    let input: String = test::black_box(repeat_n(s, LEN).collect());
+    assert_eq!(input.len(), LEN * s.len());
+    b.iter(|| {
+        let mut output = vec![];
+        unescape_mixed(&input, Mode::CStr, &mut |range, res| {
+            output.push((range, res))
+        });
+        assert_eq!(output.len(), LEN);
+        assert_eq!(output[0], ((0..s.len()), Ok(expected)));
+    });
+}
+
+#[bench]
+fn bench_unescape_c_str_trivial(b: &mut test::Bencher) {
+    bench_unescape_c_str(b, r"a", MixedUnit::Char('a'));
+}
+
+#[bench]
+fn bench_unescape_c_str_ascii(b: &mut test::Bencher) {
+    bench_unescape_c_str(b, r"\n", MixedUnit::Char('\n'));
+}
+
+#[bench]
+fn bench_unescape_c_str_hex_ascii(b: &mut test::Bencher) {
+    bench_unescape_c_str(b, r"\x22", MixedUnit::Char('"'));
+}
+
+#[bench]
+fn bench_unescape_c_str_hex_byte(b: &mut test::Bencher) {
+    bench_unescape_c_str(b, r"\xff", MixedUnit::HighByte(b'\xff'));
+}
+
+#[bench]
+fn bench_unescape_c_str_unicode(b: &mut test::Bencher) {
+    bench_unescape_c_str(b, r"\u{1f980}", MixedUnit::Char('🦀'));
+}