Add tests for serde impl's Visitor::expected (#213)

This is what is added to error messages when we're expecting an `Array`
but some other type in a self-describing format is encountered instead.

To test this we need a self-describing format, so this uses
`serde_json`, and replaces `postcard` with `serde_json` for the round
trip test since we can't use `postcard` to test both.

Author: tarcieri

Cargo.lock

@@ -29,7 +29,7 @@ zeroize = { version = "1.8", optional = true, default-features = false }
 zerocopy = { version = "0.8", optional = true, features = ["derive"] }
 
 [dev-dependencies]
-postcard = { version = "1", default-features = false, features = ["alloc"] }
+serde_json = "1"
 
 [features]
 alloc = []

Cargo.toml

@@ -75,11 +75,19 @@ mod tests {
     use crate::{Array, sizes::U3};
     type A = Array<u8, U3>;
 
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn expecting() {
+        use alloc::string::ToString;
+        let err = serde_json::from_str::<A>("true").unwrap_err();
+        assert!(err.to_string().contains("expected an array of length 3"));
+    }
+
     #[test]
     fn round_trip() {
         let example: A = Array([1, 2, 3]);
-        let bytes = postcard::to_allocvec(&example).unwrap();
-        let deserialized: A = postcard::from_bytes(&bytes).unwrap();
+        let s = serde_json::to_string(&example).unwrap();
+        let deserialized: A = serde_json::from_str(&s).unwrap();
         assert_eq!(example, deserialized);
     }
 }

src/serde.rs

@@ -258,7 +258,7 @@ mod tests {
 
         let (slice_aligned, rem_aligned) = [1u8, 2].as_hybrid_chunks::<U2>();
         assert_eq!(slice_aligned, &[Array([1u8, 2])]);
-        assert_eq!(rem_aligned, &[]);
+        assert_eq!(rem_aligned, b"");
 
         let (slice_unaligned, rem_unaligned) = [1u8, 2, 3].as_hybrid_chunks::<U2>();
         assert_eq!(slice_unaligned, &[Array([1u8, 2])]);
@@ -279,7 +279,7 @@ mod tests {
         let mut arr2 = [1u8, 2];
         let (slice_aligned, rem_aligned) = arr2.as_hybrid_chunks_mut::<U2>();
         assert_eq!(slice_aligned, &mut [Array([1u8, 2])]);
-        assert_eq!(rem_aligned, &mut []);
+        assert_eq!(rem_aligned, b"");
 
         let mut arr3 = [1u8, 2, 3];
         let (slice_unaligned, rem_unaligned) = arr3.as_hybrid_chunks_mut::<U2>();