1 files changed, 170 insertions, 0 deletions
diff --git a/third_party/rust/smart-default/tests/tests.rs b/third_party/rust/smart-default/tests/tests.rs
new file mode 100644
index 0000000000..423c91df33
--- /dev/null
+++ b/third_party/rust/smart-default/tests/tests.rs
@@ -0,0 +1,170 @@
+use smart_default::SmartDefault;
+
+#[test]
+fn test_unit() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo;
+
+    assert!(Foo::default() == Foo);
+}
+
+#[test]
+fn test_tuple() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo(
+        #[default = 10] i32,
+        #[default = 20] i32,
+        // No default
+        i32,
+    );
+
+    assert!(Foo::default() == Foo(10, 20, 0));
+}
+
+#[test]
+fn test_struct() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo {
+        #[default = 10]
+        x: i32,
+        #[default = 20]
+        y: i32,
+        // No default
+        z: i32,
+    }
+
+    assert!(Foo::default() == Foo { x: 10, y: 20, z: 0 });
+}
+
+#[test]
+fn test_enum_of_units() {
+    #[derive(PartialEq, SmartDefault)]
+    pub enum Foo {
+        #[allow(dead_code)]
+        Bar,
+        #[default]
+        Baz,
+        #[allow(dead_code)]
+        Qux,
+    }
+
+    assert!(Foo::default() == Foo::Baz);
+}
+
+#[test]
+fn test_enum_of_tuples() {
+    #[derive(PartialEq, SmartDefault)]
+    pub enum Foo {
+        #[allow(dead_code)]
+        Bar(i32),
+        #[default]
+        Baz(#[default = 10] i32, i32),
+        #[allow(dead_code)]
+        Qux(i32),
+    }
+
+    assert!(Foo::default() == Foo::Baz(10, 0));
+}
+
+#[test]
+fn test_enum_of_structs() {
+    #[derive(PartialEq, SmartDefault)]
+    pub enum Foo {
+        #[allow(dead_code)]
+        Bar { x: i32 },
+        #[default]
+        Baz {
+            #[default = 10]
+            y: i32,
+            z: i32,
+        },
+        #[allow(dead_code)]
+        Qux { w: i32 },
+    }
+
+    assert!(Foo::default() == Foo::Baz { y: 10, z: 0 });
+}
+
+#[test]
+fn test_enum_mixed() {
+    #[derive(PartialEq, SmartDefault)]
+    enum Foo {
+        #[allow(dead_code)]
+        Bar,
+        #[default]
+        Baz(#[default = 10] i32),
+        #[allow(dead_code)]
+        Qux { w: i32 },
+    }
+
+    assert!(Foo::default() == Foo::Baz(10));
+}
+
+#[test]
+fn test_generics_type_parameters() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo<T>
+    where
+        T: Default,
+    {
+        #[default(Some(Default::default()))]
+        x: Option<T>,
+    }
+
+    assert!(Foo::default() == Foo { x: Some(0) });
+}
+
+#[test]
+fn test_generics_lifetime_parameters() {
+    // NOTE: A default value makes no sense with lifetime parameters, since ::default() receives no
+    // paramters and therefore can receive no lifetimes. But it does make sense if you make a variant
+    // without ref fields the default.
+
+    #[derive(PartialEq, SmartDefault)]
+    enum Foo<'a> {
+        #[default]
+        Bar(i32),
+        #[allow(dead_code)]
+        Baz(&'a str),
+    }
+
+    assert!(Foo::default() == Foo::Bar(0));
+}
+
+#[test]
+fn test_code_hack() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo {
+        #[default(_code = "vec![1, 2, 3]")]
+        v: Vec<u32>,
+    }
+
+    assert!(Foo::default().v == [1, 2, 3]);
+}
+
+#[test]
+fn test_string_conversion() {
+    #[derive(PartialEq, SmartDefault)]
+    struct Foo(#[default = "one"] &'static str, #[default("two")] String);
+
+    assert!(Foo::default() == Foo("one", "two".to_owned()));
+}
+
+#[test]
+fn test_non_code_hack_valid_meta() {
+    #[derive(Debug, PartialEq, SmartDefault)]
+    struct Foo {
+        #[default(true)]
+        bar: bool,
+        #[default(Option::None)]
+        baz: Option<()>,
+    }
+
+    assert_eq!(
+        Foo::default(),
+        Foo {
+            bar: true,
+            baz: None
+        }
+    );
+}