test fmt::Debug

Author: carllerche

tests/tests/listable.rs

@@ -184,6 +184,12 @@ macro_rules! test_primitive {
                     fn visit_slice(&mut self, slice: Slice<'_>) {
                         assert_eq!(slice.len(), self.0.len());
 
+                        // fmt::Debug
+                        assert_eq!(
+                            format!("{:?}", slice),
+                            format!("{:?}", self.0),
+                        );
+
                         // Test the expected variant has been received
                         match slice {
                             Slice::$variant(slice) => {

tests/tests/structable.rs

@@ -1,6 +1,80 @@
 use valuable::field::*;
 use valuable::*;
 
+#[test]
+fn test_manual_static_impl() {
+    struct MyStruct {
+        num: u32,
+        list: Vec<String>,
+        sub: SubStruct,
+    }
+
+    static MY_STRUCT_FIELDS: &[NamedField<'static>] = &[
+        NamedField::new("num"),
+        NamedField::new("list"),
+        NamedField::new("sub"),
+    ];
+
+    struct SubStruct {
+        message: &'static str,
+    }
+
+    static SUB_STRUCT_FIELDS: &[NamedField<'static>] = &[NamedField::new("message")];
+
+    impl Valuable for MyStruct {
+        fn as_value(&self) -> Value<'_> {
+            Value::Structable(self)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            visit.visit_named_fields(&NamedValues::new(
+                MY_STRUCT_FIELDS,
+                &[
+                    Value::U32(self.num),
+                    Value::Listable(&self.list),
+                    Value::Structable(&self.sub),
+                ],
+            ));
+        }
+    }
+
+    impl Structable for MyStruct {
+        fn definition(&self) -> StructDef<'_> {
+            StructDef::new("MyStruct", Fields::NamedStatic(MY_STRUCT_FIELDS), false)
+        }
+    }
+
+    impl Valuable for SubStruct {
+        fn as_value(&self) -> Value<'_> {
+            Value::Structable(self)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            visit.visit_named_fields(&NamedValues::new(
+                SUB_STRUCT_FIELDS,
+                &[Value::String(self.message)],
+            ));
+        }
+    }
+
+    impl Structable for SubStruct {
+        fn definition(&self) -> StructDef<'_> {
+            StructDef::new("SubStruct", Fields::NamedStatic(SUB_STRUCT_FIELDS), false)
+        }
+    }
+
+    let my_struct = MyStruct {
+        num: 12,
+        list: vec!["hello".to_string()],
+        sub: SubStruct { message: "world" },
+    };
+
+    assert_eq!(
+        format!("{:?}", my_struct.as_value()),
+        "MyStruct { num: 12, list: [\"hello\"], sub: SubStruct { message: \"world\" } }"
+    );
+}
+
 #[test]
 fn test_named_field() {
     let name = "hello".to_string();
@@ -42,11 +116,7 @@ fn test_fields_unnamed() {
 
 #[test]
 fn test_struct_def() {
-    let def = StructDef::new(
-        "hello",
-        Fields::Unnamed,
-        false,
-    );
+    let def = StructDef::new("hello", Fields::Unnamed, false);
 
     assert_eq!(def.name(), "hello");
     assert!(matches!(def.fields(), Fields::Unnamed));
@@ -55,18 +125,9 @@ fn test_struct_def() {
 
 #[test]
 fn test_named_values() {
-    let fields = [
-        NamedField::new("foo"),
-        NamedField::new("bar"),
-    ];
+    let fields = [NamedField::new("foo"), NamedField::new("bar")];
 
-    let vals = NamedValues::new(
-        &fields[..],
-        &[
-            Value::U32(123),
-            Value::String("hello"),
-        ]
-    );
+    let vals = NamedValues::new(&fields[..], &[Value::U32(123), Value::String("hello")]);
 
     let other_field = NamedField::new("foo");
 

tests/tests/value.rs

@@ -60,6 +60,12 @@ macro_rules! assert_value {
             let mut visit = VisitValue(src, std::marker::PhantomData);
             val.visit(&mut visit);
 
+            // fmt::Debug
+            assert_eq!(
+                format!("{:?}", val),
+                format!("{:?}", src),
+            );
+
             // Test conversion
             assert!(matches!(val, $variant(v) if $eq(&v, &src)));