test: Add more tests

sailfish/src/runtime/buffer.rs

@@ -333,7 +333,9 @@ unsafe impl Sync for Buffer {}
 
 #[cfg(test)]
 mod tests {
-    use super::Buffer;
+    use super::*;
+    use std::sync::{Arc, Barrier, Mutex};
+    use std::thread;
 
     #[test]
     fn push_str() {
@@ -348,6 +350,13 @@ mod tests {
         buffer.push_str("pie");
         assert_eq!(buffer.len(), 8);
         assert_eq!(buffer.capacity(), 10);
+
+        for _ in 0..16 {
+            buffer.push_str("zomg");
+        }
+
+        assert_eq!(buffer.len(), 72);
+        assert_eq!(buffer.capacity(), 80);
     }
 
     #[test]
@@ -361,9 +370,15 @@ mod tests {
     #[test]
     fn string_conversion() {
         // from empty string
-        let s = String::new();
+        let s = String::with_capacity(2);
+        assert!(s.capacity() >= 2);
+
         let mut buf = Buffer::from(s);
         assert_eq!(buf.as_str(), "");
+
+        // capacity should be shrinked for safety
+        assert_eq!(buf.capacity(), 0);
+
         buf.push_str("abc");
         assert_eq!(buf.as_str(), "abc");
 
@@ -389,6 +404,12 @@ mod tests {
         assert_eq!(s, "apple");
     }
 
+    #[test]
+    fn from_str() {
+        let buf = Buffer::from("abcdefgh");
+        assert_eq!(buf.as_str(), "abcdefgh");
+    }
+
     #[test]
     fn clone() {
         use std::fmt::Write;
@@ -428,4 +449,45 @@ mod tests {
             assert_eq!(s.as_str(), "aéＡ🄫");
         }
     }
+
+    #[test]
+    fn multi_thread() {
+        const THREADS: usize = 8;
+        const ITERS: usize = 100;
+
+        let barrier = Arc::new(Barrier::new(THREADS));
+        let buffer = Arc::new(Mutex::new(Buffer::new()));
+        let mut handles = Vec::with_capacity(THREADS);
+
+        for _ in 0..THREADS {
+            let barrier = barrier.clone();
+            let buffer = buffer.clone();
+
+            handles.push(thread::spawn(move || {
+                barrier.wait();
+                for _ in 0..ITERS {
+                    buffer.lock().unwrap().push_str("a");
+                }
+            }));
+        }
+
+        for handle in handles {
+            handle.join().unwrap();
+        }
+
+        assert_eq!(buffer.lock().unwrap().as_str(), "a".repeat(ITERS * THREADS));
+    }
+
+    #[test]
+    #[should_panic]
+    fn reserve_overflow() {
+        let mut buf = Buffer::new();
+        buf.reserve(std::isize::MAX as usize + 1);
+    }
+
+    #[test]
+    #[should_panic]
+    fn empty_alloc() {
+        safe_alloc(0);
+    }
 }

sailfish/src/runtime/filter.rs

@@ -366,20 +366,111 @@ mod tests {
     }
 
     #[test]
-    fn case() {
-        assert_render(&upper("hElLo, WOrLd!"), "HELLO, WORLD!");
-        assert_render(&lower("hElLo, WOrLd!"), "hello, world!");
+    fn test_lower() {
+        assert_render(&lower(""), "");
+        assert_render_escaped(&lower(""), "");
+
+        assert_render(&lower("lorem ipsum"), "lorem ipsum");
+        assert_render(&lower("LOREM IPSUM"), "lorem ipsum");
+
+        assert_render_escaped(&lower("hElLo, WOrLd!"), "hello, world!");
+        assert_render_escaped(&lower("hElLo, WOrLd!"), "hello, world!");
+
         assert_render_escaped(&lower("<h1>TITLE</h1>"), "&lt;h1&gt;title&lt;/h1&gt;");
+        assert_render_escaped(&lower("<<&\"\">>"), "&lt;&lt;&amp;&quot;&quot;&gt;&gt;");
+
+        // non-ascii
+        assert_render(&lower("aBcＡｂｃ"), "abcａｂｃ");
+        assert_render(&lower("ὈΔΥΣΣΕΎΣ"), "ὀδυσσεύς");
     }
 
     #[test]
-    fn trim_test() {
+    fn test_upper() {
+        assert_render(&upper(""), "");
+        assert_render_escaped(&upper(""), "");
+
+        assert_render(&upper("lorem ipsum"), "LOREM IPSUM");
+        assert_render(&upper("LOREM IPSUM"), "LOREM IPSUM");
+
+        assert_render(&upper("hElLo, WOrLd!"), "HELLO, WORLD!");
+        assert_render(&upper("hElLo, WOrLd!"), "HELLO, WORLD!");
+
+        // non-ascii
+        assert_render(&upper("aBcＡｂｃ"), "ABCＡＢＣ");
+        assert_render(&upper("tschüß"), "TSCHÜSS");
+    }
+
+    #[test]
+    fn test_trim() {
         assert_render(&trim(""), "");
+        assert_render_escaped(&trim(""), "");
+
         assert_render(&trim("\n \t\r\x0C"), "");
 
         assert_render(&trim("hello world!"), "hello world!");
         assert_render(&trim("hello world!\n"), "hello world!");
         assert_render(&trim("\thello world!"), "hello world!");
         assert_render(&trim("\thello world!\r\n"), "hello world!");
+
+        assert_render_escaped(&trim(" <html>  "), "&lt;html&gt;");
+        assert_render_escaped(&lower("<<&\"\">>"), "&lt;&lt;&amp;&quot;&quot;&gt;&gt;");
+
+        // non-ascii whitespace
+        assert_render(&trim("\u{A0}空白\u{3000}\u{205F}"), "空白");
+    }
+
+    #[test]
+    fn test_truncate() {
+        assert_render(&truncate("", 0), "");
+        assert_render(&truncate("", 5), "");
+
+        assert_render(&truncate("apple ", 0), "...");
+        assert_render(&truncate("apple ", 1), "a...");
+        assert_render(&truncate("apple ", 2), "ap...");
+        assert_render(&truncate("apple ", 3), "app...");
+        assert_render(&truncate("apple ", 4), "appl...");
+        assert_render(&truncate("apple ", 5), "apple...");
+        assert_render(&truncate("apple ", 6), "apple ");
+        assert_render(&truncate("apple ", 7), "apple ");
+
+        assert_render(&truncate(&std::f64::consts::PI, 10), "3.14159265...");
+        assert_render(&truncate(&std::f64::consts::PI, 20), "3.141592653589793");
+
+        assert_render_escaped(&truncate("foo<br>bar", 10), "foo&lt;br&...");
+        assert_render_escaped(&truncate("foo<br>bar", 20), "foo&lt;br&gt;bar");
+
+        // non-ascii
+        assert_render(&truncate("魑魅魍魎", 0), "...");
+        assert_render(&truncate("魑魅魍魎", 1), "魑...");
+        assert_render(&truncate("魑魅魍魎", 2), "魑魅...");
+        assert_render(&truncate("魑魅魍魎", 3), "魑魅魍...");
+        assert_render(&truncate("魑魅魍魎", 4), "魑魅魍魎");
+        assert_render(&truncate("魑魅魍魎", 5), "魑魅魍魎");
+    }
+
+    #[cfg(feature = "json")]
+    #[test]
+    fn test_json() {
+        assert_render(&json(""), "\"\"");
+        assert_render(&json(&serde_json::json!({})), "{}");
+
+        assert_render_escaped(&json(&123_i32), "123");
+        assert_render_escaped(&json("Pokémon"), "&quot;Pokémon&quot;");
+    }
+
+    #[test]
+    fn compine() {
+        assert_render(
+            &lower(&upper("Li Europan lingues es membres del sam familie.")),
+            "li europan lingues es membres del sam familie.",
+        );
+        assert_render(&lower(&lower("ハートのＡ")), "ハートのａ");
+        assert_render(&upper(&upper("ハートのＡ")), "ハートのＡ");
+
+        assert_render(&truncate(&trim("\t起来！\r\n"), 1), "起...");
+        assert_render(&truncate(&trim("\t起来！\r\n"), 3), "起来！");
+
+        assert_render(&truncate(&lower("Was möchtest du?"), 10), "was möchte...");
+        assert_render(&truncate(&upper("Was möchtest du?"), 10), "WAS MÖCHTE...");
     }
 }

sailfish/src/runtime/render.rs

@@ -485,6 +485,32 @@ mod tests {
         assert_eq!(b.as_str(), "0.0inf-infNaN");
     }
 
+    #[test]
+    fn test_char() {
+        let mut b = Buffer::new();
+
+        let funcs: Vec<fn(&char, &mut Buffer) -> Result<(), RenderError>> =
+            vec![Render::render, Render::render_escaped];
+
+        for func in funcs {
+            func(&'a', &mut b).unwrap();
+            func(&'b', &mut b).unwrap();
+            func(&'c', &mut b).unwrap();
+            func(&'d', &mut b).unwrap();
+
+            assert_eq!(b.as_str(), "abcd");
+            b.clear();
+
+            func(&'あ', &mut b).unwrap();
+            func(&'い', &mut b).unwrap();
+            func(&'う', &mut b).unwrap();
+            func(&'え', &mut b).unwrap();
+
+            assert_eq!(b.as_str(), "あいうえ");
+            b.clear();
+        }
+    }
+
     #[test]
     fn render_error() {
         let err = RenderError::new("custom error");