Add test cases

Author: LaurenzV

src/annotations.rs

@@ -796,10 +796,13 @@ mod tests {
     #[test]
     fn test_annotations() {
         test!(
-            crate::tests::slice(|w| {
-                w.annotation(Ref::new(1)).rect(Rect::new(0.0, 0.0, 1.0, 1.0));
-                w.annotation(Ref::new(2)).rect(Rect::new(1.0, 1.0, 0.0, 0.0));
-            }),
+            crate::tests::slice(
+                |w| {
+                    w.annotation(Ref::new(1)).rect(Rect::new(0.0, 0.0, 1.0, 1.0));
+                    w.annotation(Ref::new(2)).rect(Rect::new(1.0, 1.0, 0.0, 0.0));
+                },
+                WriteSettings::default()
+            ),
             b"1 0 obj",
             b"<<",
             b"  /Type /Annot",

src/lib.rs

@@ -199,12 +199,12 @@ pub use self::object::{
     TypedDict, Writer,
 };
 
+use self::writers::*;
+use crate::chunk::WriteSettings;
 use std::fmt::{self, Debug, Formatter};
 use std::io::Write;
 use std::ops::{Deref, DerefMut};
 
-use self::writers::*;
-
 /// A builder for a PDF file.
 ///
 /// This type constructs a PDF file in-memory. Aside from a few specific
@@ -227,6 +227,14 @@ impl Pdf {
         Self::with_capacity(8 * 1024)
     }
 
+    /// Create a new PDF with the given write settings.
+    pub fn new_with(write_settings: WriteSettings) -> Self {
+        let mut pdf = Self::new();
+        pdf.write_settings = write_settings;
+
+        pdf
+    }
+
     /// Create a new PDF with the specified initial buffer capacity.
     pub fn with_capacity(capacity: usize) -> Self {
         let mut chunk = Chunk::with_capacity(capacity);
@@ -412,11 +420,11 @@ mod tests {
     }
 
     /// Return the slice of bytes written during the execution of `f`.
-    pub fn slice<F>(f: F) -> Vec<u8>
+    pub fn slice<F>(f: F, write_settings: WriteSettings) -> Vec<u8>
     where
         F: FnOnce(&mut Pdf),
     {
-        let mut w = Pdf::new();
+        let mut w = Pdf::new_with(write_settings);
         let start = w.len();
         f(&mut w);
         let end = w.len();
@@ -425,12 +433,16 @@ mod tests {
     }
 
     /// Return the slice of bytes written for an object.
-    pub fn slice_obj<F>(f: F) -> Vec<u8>
+    pub fn slice_obj<F>(f: F, write_settings: WriteSettings) -> Vec<u8>
     where
         F: FnOnce(Obj<'_>),
     {
-        let buf = slice(|w| f(w.indirect(Ref::new(1))));
-        buf[8..buf.len() - 9].to_vec()
+        let buf = slice(|w| f(w.indirect(Ref::new(1))), write_settings);
+        if write_settings.pretty {
+            buf[8..buf.len() - 9].to_vec()
+        } else {
+            buf[8..buf.len() - 8].to_vec()
+        }
     }
 
     #[test]

src/macros.rs

@@ -19,7 +19,15 @@ macro_rules! test {
 #[cfg(test)]
 macro_rules! test_obj {
     (|$obj:ident| $write:expr, $($tts:tt)*) => {{
-        test!(crate::tests::slice_obj(|$obj| { $write; }), $($tts)*)
+        test!(crate::tests::slice_obj(|$obj| { $write; }, crate::WriteSettings::default()), $($tts)*)
+    }}
+}
+
+/// Test how an object is written, without pretty-printing.
+#[cfg(test)]
+macro_rules! test_obj_no_pretty {
+    (|$obj:ident| $write:expr, $($tts:tt)*) => {{
+        test!(crate::tests::slice_obj(|$obj| { $write; }, crate::WriteSettings { pretty: false }), $($tts)*)
     }}
 }
 

src/object.rs

@@ -1686,4 +1686,37 @@ mod tests {
             b"startxref\n94\n%%EOF",
         )
     }
+
+    #[test]
+    fn test_arrays_no_pretty() {
+        test_obj_no_pretty!(|obj| obj.array(), b"[]");
+        test_obj_no_pretty!(
+            |obj| obj
+                .array()
+                .item(12)
+                .item(Name(b"Hi"))
+                .item(Name(b"Hi2"))
+                .item(false)
+                .item(TextStr("A string"))
+                .item(Null)
+                .item(23.40),
+            b"[12/Hi/Hi2 false(A String)null 23.4]"
+        );
+    }
+
+    #[test]
+    fn test_dicts_no_pretty() {
+        test_obj_no_pretty!(|obj| obj.dict(), b"<<>>");
+        test_obj_no_pretty!(
+            |obj| obj
+                .dict()
+                .pair(Name(b"Key1"), 12)
+                .pair(Name(b"Key2"), Name(b"Hi"))
+                .pair(Name(b"Key3"), false)
+                .pair(Name(b"Key4"), TextStr("A string"))
+                .pair(Name(b"Key5"), Null)
+                .pair(Name(b"Key6"), 23.40),
+            b"<</Key1 12/Key2/Hi/Key3 false/Key4(A string)/Key5 null/Key6 23.4>>"
+        );
+    }
 }