Add more tests for runtime

sailfish/src/runtime/buffer.rs

@@ -312,11 +312,34 @@ mod tests {
         assert_eq!(buf.as_str(), "");
 
         // into empty string
-        let buf = Buffer::new();
+        let buf = Buffer::default();
         let mut s = buf.into_string();
         assert_eq!(s, "");
 
         s.push_str("apple");
         assert_eq!(s, "apple");
     }
+
+    #[test]
+    fn clone() {
+        use std::fmt::Write;
+
+        let mut s1 = Buffer::with_capacity(0);
+        let mut s2 = s1.clone();
+
+        s1.push('a');
+        s2.push_str("b");
+
+        assert_eq!(s1.as_str(), "a");
+        assert_eq!(s2.as_str(), "b");
+
+        let mut s1 = Buffer::from("foo");
+        let mut s2 = s1.clone();
+
+        s1 = s1 + "bar";
+        write!(s2, "baz").unwrap();
+
+        assert_eq!(s1.as_str(), "foobar");
+        assert_eq!(s2.as_str(), "foobaz");
+    }
 }

sailfish/src/runtime/escape/mod.rs

@@ -119,6 +119,7 @@ mod tests {
     #[test]
     fn noescape() {
         assert_eq!(escape(""), "");
+        assert_eq!(escape("1234567890"), "1234567890");
         assert_eq!(
             escape("abcdefghijklmnopqrstrvwxyz"),
             "abcdefghijklmnopqrstrvwxyz"
@@ -159,12 +160,12 @@ mod tests {
         const ASCII_CHARS: &'static [u8] = br##"abcdefghijklmnopqrstuvwxyz0123456789-^\@[;:],./\!"#$%&'()~=~|`{+*}<>?_"##;
         let mut state = 88172645463325252u64;
         let mut data = Vec::with_capacity(100);
-        let mut buf1 = Buffer::new();
-        let mut buf2 = Buffer::new();
-        let mut buf3 = Buffer::new();
 
-        for len in 0..100 {
-            for _ in 0..10 {
+        let mut buf_naive = Buffer::new();
+        let mut buf = Buffer::new();
+
+        for len in 16..100 {
+            for _ in 0..5 {
                 data.clear();
                 for _ in 0..len {
                     // xorshift
@@ -178,23 +179,33 @@ mod tests {
 
                 let s = unsafe { std::str::from_utf8_unchecked(&*data) };
 
-                buf1.clear();
-                buf2.clear();
-                buf3.clear();
-
                 unsafe {
-                    escape_to_buf(s, &mut buf1);
-                    fallback::escape(s, &mut buf2);
                     naive::escape(
-                        &mut buf3,
+                        &mut buf_naive,
                         s.as_ptr(),
                         s.as_ptr(),
                         s.as_ptr().add(s.len()),
                     );
+
+                    dbg!(s);
+                    fallback::escape(s, &mut buf);
+                    assert_eq!(buf.as_str(), buf_naive.as_str());
+                    buf.clear();
+
+                    if is_x86_feature_detected!("sse2") {
+                        sse2::escape(s, &mut buf);
+                        assert_eq!(buf.as_str(), buf_naive.as_str());
+                        buf.clear();
+                    }
+
+                    if is_x86_feature_detected!("avx2") {
+                        avx2::escape(s, &mut buf);
+                        assert_eq!(buf.as_str(), buf_naive.as_str());
+                        buf.clear();
+                    }
                 }
 
-                assert_eq!(buf1.as_str(), buf3.as_str());
-                assert_eq!(buf2.as_str(), buf3.as_str());
+                buf_naive.clear();
             }
         }
     }

sailfish/src/runtime/mod.rs

@@ -98,3 +98,19 @@ impl Context {
 //     buffer.push_str("</table>");
 //     buffer.into_string()
 // }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::error::Error;
+
+    #[test]
+    fn render_error() {
+        let err = RenderError::new("custom error");
+        assert!(err.source().is_none());
+        assert_eq!(format!("{}", err), "custom error");
+
+        let err = RenderError::from(std::fmt::Error::default());
+        assert!(err.source().is_some());
+    }
+}

sailfish/src/runtime/render.rs

@@ -269,12 +269,11 @@ mod tests {
         assert_eq!(b.as_str(), "1111");
         b.clear();
 
-        let v = 2.0;
-        (&v)._sf_r_internal(&mut b).unwrap();
-        (&&v)._sf_r_internal(&mut b).unwrap();
-        (&&&v)._sf_r_internal(&mut b).unwrap();
-        (&&&&v)._sf_r_internal(&mut b).unwrap();
-        assert_eq!(b.as_str(), "2.02.02.02.0");
+        (&true)._sf_r_internal(&mut b).unwrap();
+        (&&false)._sf_r_internal(&mut b).unwrap();
+        (&&&true)._sf_r_internal(&mut b).unwrap();
+        (&&&&false)._sf_r_internal(&mut b).unwrap();
+        assert_eq!(b.as_str(), "truefalsetruefalse");
         b.clear();
 
         let s = "apple";
@@ -307,4 +306,22 @@ mod tests {
 
         assert_eq!(b.as_str(), "ab42.3");
     }
+
+    #[test]
+    fn float() {
+        let mut b = Buffer::new();
+
+        (&0.0f64)._sf_re_internal(&mut b).unwrap();
+        (&std::f64::INFINITY)._sf_re_internal(&mut b).unwrap();
+        (&std::f64::NEG_INFINITY)._sf_re_internal(&mut b).unwrap();
+        (&std::f64::NAN)._sf_re_internal(&mut b).unwrap();
+        assert_eq!(b.as_str(), "0.0inf-infNaN");
+        b.clear();
+
+        (&0.0f32)._sf_re_internal(&mut b).unwrap();
+        (&std::f32::INFINITY)._sf_re_internal(&mut b).unwrap();
+        (&std::f32::NEG_INFINITY)._sf_re_internal(&mut b).unwrap();
+        (&std::f32::NAN)._sf_re_internal(&mut b).unwrap();
+        assert_eq!(b.as_str(), "0.0inf-infNaN");
+    }
 }