Add Box type

1 files changed, 304 insertions, 0 deletions

diff --git a/examples/14-transient-0/output/rust/src/lib.rs b/examples/14-transient-0/output/rust/src/lib.rs
new file mode 100644
index 0000000..df50cae
--- /dev/null
+++ b/examples/14-transient-0/output/rust/src/lib.rs
@@ -0,0 +1,304 @@
+pub mod data;
+pub mod transient_0;
+
+#[cfg(test)]
+mod test {
+    use std::any::Any;
+    use std::io::Cursor;
+    use std::path::PathBuf;
+    use std::sync::Arc;
+    use std::collections::HashMap;
+    use super::data::{EnumWithVariants, StructSingleton, StructWithBool, StructWithDifferentSharedTypes, StructWithEnum, StructWithInt8, StructWithInt32, StructWithInt64, StructWithList, StructWithListOfShared, StructWithOption, StructWithSharedSumAndVariant, StructWithString, StructWithStruct, StructWithSum, SumWithBoxedVariants, SumWithVariants, VariantOne, VariantTwo };
+
+    #[test]
+    fn struct_singleton() {
+        let value = StructSingleton;
+
+        assert_round_trip_encoding(
+            "StructSingleton",
+            value,
+            super::data::transient_0::encode_struct_singleton,
+            super::data::transient_0::decode_struct_singleton,
+        );
+    }
+
+    #[test]
+    fn struct_with_bool() {
+        let value = StructWithBool { a: true, b: false };
+
+        assert_round_trip_encoding(
+            "StructWithBool",
+            value,
+            super::data::transient_0::encode_struct_with_bool,
+            super::data::transient_0::decode_struct_with_bool,
+        );
+    }
+
+    #[test]
+    fn struct_with_int_8() {
+        let value = StructWithInt8 { a: 10, b: 25 };
+
+        assert_round_trip_encoding(
+            "StructWithInt8",
+            value,
+            super::data::transient_0::encode_struct_with_int_8,
+            super::data::transient_0::decode_struct_with_int_8,
+        );
+    }
+
+    #[test]
+    fn struct_with_int_32() {
+        let value = StructWithInt32 { a: 10, b: 25 };
+
+        assert_round_trip_encoding(
+            "StructWithInt32",
+            value,
+            super::data::transient_0::encode_struct_with_int_32,
+            super::data::transient_0::decode_struct_with_int_32,
+        );
+    }
+
+    #[test]
+    fn struct_with_int_64() {
+        let value = StructWithInt64 { a: 10, b: 25 };
+
+        assert_round_trip_encoding(
+            "StructWithInt64",
+            value,
+            super::data::transient_0::encode_struct_with_int_64,
+            super::data::transient_0::decode_struct_with_int_64,
+        );
+    }
+
+    #[test]
+    fn struct_with_string() {
+        let value = StructWithString { a: "abc".to_string(), b: "def".to_string() };
+
+        assert_round_trip_encoding(
+            "StructWithString",
+            value,
+            super::data::transient_0::encode_struct_with_string,
+            super::data::transient_0::decode_struct_with_string,
+        );
+    }
+
+    #[test]
+    fn struct_with_struct() {
+        let value = StructWithStruct { inner: StructWithInt32 { a: 10, b: 25 }, c: 42 };
+
+        assert_round_trip_encoding(
+            "StructWithStruct",
+            value,
+            super::data::transient_0::encode_struct_with_struct,
+            super::data::transient_0::decode_struct_with_struct,
+        );
+    }
+
+    #[test]
+    fn struct_with_list() {
+        let value = StructWithList {
+            a: vec![10, 25],
+            b: vec![
+                StructWithInt32 { a: 42, b: 47 },
+                StructWithInt32 { a: 52, b: 57 },
+                StructWithInt32 { a: 62, b: 67 },
+            ],
+        };
+
+        assert_round_trip_encoding(
+            "StructWithList",
+            value,
+            super::data::transient_0::encode_struct_with_list,
+            super::data::transient_0::decode_struct_with_list,
+        );
+    }
+
+    #[test]
+    fn struct_with_option_none() {
+        let value = StructWithOption {
+            a: None,
+            b: None,
+        };
+
+        assert_round_trip_encoding(
+            "StructWithOption_None",
+            value,
+            super::data::transient_0::encode_struct_with_option,
+            super::data::transient_0::decode_struct_with_option,
+        );
+    }
+
+    #[test]
+    fn struct_with_option_some() {
+        let value = StructWithOption {
+            a: Some(10),
+            b: Some(StructWithInt32 { a: 42, b: 47 }),
+        };
+
+        assert_round_trip_encoding(
+            "StructWithOption_Some",
+            value,
+            super::data::transient_0::encode_struct_with_option,
+            super::data::transient_0::decode_struct_with_option,
+        );
+    }
+
+    #[test]
+    fn enum_with_variants() {
+        assert_round_trip_encoding(
+            "EnumWithVariants_zero",
+            EnumWithVariants::Zero,
+            super::data::transient_0::encode_enum_with_variants,
+            super::data::transient_0::decode_enum_with_variants,
+        );
+
+        assert_round_trip_encoding(
+            "EnumWithVariants_one",
+            EnumWithVariants::One,
+            super::data::transient_0::encode_enum_with_variants,
+            super::data::transient_0::decode_enum_with_variants,
+        );
+
+        assert_round_trip_encoding(
+            "EnumWithVariants_two",
+            EnumWithVariants::Two,
+            super::data::transient_0::encode_enum_with_variants,
+            super::data::transient_0::decode_enum_with_variants,
+        );
+    }
+
+    #[test]
+    fn struct_with_enum() {
+        let value = StructWithEnum { inner: EnumWithVariants::One, c: 42 };
+
+        assert_round_trip_encoding(
+            "StructWithEnum",
+            value,
+            super::data::transient_0::encode_struct_with_enum,
+            super::data::transient_0::decode_struct_with_enum,
+        );
+    }
+
+    #[test]
+    fn sum_with_variants() {
+        assert_round_trip_encoding(
+            "SumWithVariants_VariantOne",
+            SumWithVariants::VariantOne(VariantOne { a: 10 }),
+            super::data::transient_0::encode_sum_with_variants,
+            super::data::transient_0::decode_sum_with_variants,
+        );
+
+        assert_round_trip_encoding(
+            "SumWithVariants_VariantTwo",
+            SumWithVariants::VariantTwo(VariantTwo { a: 25 }),
+            super::data::transient_0::encode_sum_with_variants,
+            super::data::transient_0::decode_sum_with_variants,
+        );
+    }
+
+    #[test]
+    fn sum_with_boxed_variants() {
+        assert_round_trip_encoding(
+            "SumWithBoxedVariants_VariantOne",
+            SumWithBoxedVariants::VariantOne(Box::new(VariantOne { a: 10 })),
+            super::data::transient_0::encode_sum_with_boxed_variants,
+            super::data::transient_0::decode_sum_with_boxed_variants,
+        );
+
+        assert_round_trip_encoding(
+            "SumWithBoxedVariants_VariantTwo",
+            SumWithBoxedVariants::VariantTwo(Box::new(VariantTwo { a: 25 })),
+            super::data::transient_0::encode_sum_with_boxed_variants,
+            super::data::transient_0::decode_sum_with_boxed_variants,
+        );
+    }
+
+    #[test]
+    fn struct_with_sum() {
+        let value = StructWithSum {
+            inner: SumWithVariants::VariantTwo(VariantTwo { a: 25 }),
+            b: 42,
+        };
+
+        assert_round_trip_encoding(
+            "StructWithSum",
+            value,
+            super::data::transient_0::encode_struct_with_sum,
+            super::data::transient_0::decode_struct_with_sum,
+        );
+    }
+
+    #[test]
+    fn struct_with_list_of_shared() {
+        let a = Arc::new(StructWithInt32 { a: 10, b: 25 });
+        let b = Arc::new(StructWithInt32 { a: 42, b: 47 });
+
+        let value = StructWithListOfShared {
+            inner: vec![Arc::clone(&a), Arc::clone(&a), Arc::clone(&b), a, b],
+        };
+
+        let decoded_value = assert_round_trip_encoding(
+            "StructWithListOfShared",
+            value,
+            super::data::transient_0::encode_struct_with_list_of_shared,
+            super::data::transient_0::decode_struct_with_list_of_shared,
+        );
+        assert!(Arc::ptr_eq(&decoded_value.inner[0], &decoded_value.inner[1]));
+        assert!(Arc::ptr_eq(&decoded_value.inner[0], &decoded_value.inner[3]));
+        assert!(Arc::ptr_eq(&decoded_value.inner[2], &decoded_value.inner[4]));
+    }
+
+    #[test]
+    fn struct_with_different_shared_types() {
+        let a = Arc::new(StructWithInt32 { a: 10, b: 25 });
+        let b = Arc::new(StructWithInt64 { a: 42, b: 47 });
+        let c = Arc::new(StructWithInt32 { a: 52, b: 57 });
+
+        let value = StructWithDifferentSharedTypes { a, b, c };
+
+        assert_round_trip_encoding(
+            "StructWithDifferentSharedTypes",
+            value,
+            super::data::transient_0::encode_struct_with_different_shared_types,
+            super::data::transient_0::decode_struct_with_different_shared_types,
+        );
+    }
+
+    #[test]
+    fn struct_with_shared_sum_and_variant() {
+        let a = Arc::new(SumWithVariants::VariantOne(VariantOne { a: 10 }));
+        let b = Arc::new(VariantOne { a: 10 });
+
+        let value = StructWithSharedSumAndVariant { a, b };
+
+        assert_round_trip_encoding(
+            "StructWithSharedSumAndVariant",
+            value,
+            super::data::transient_0::encode_struct_with_shared_sum_and_variant,
+            super::data::transient_0::decode_struct_with_shared_sum_and_variant,
+        );
+    }
+
+    fn assert_round_trip_encoding<T: std::cmp::PartialEq + std::fmt::Debug>(
+        name: &str,
+        value: T,
+        encode: impl Fn(&T, &mut Cursor<Vec<u8>>, &mut HashMap<usize, i64>) -> std::io::Result<()>,
+        decode: impl Fn(&mut Cursor<Vec<u8>>, &mut Vec<Arc<dyn Any + Sync + Send>>) -> std::io::Result<T>,
+    ) -> T {
+        let mut bytes = Cursor::new(Vec::new());
+        encode(&value, &mut bytes, &mut HashMap::new()).unwrap();
+
+        let output_dir = std::env::var("HOBGOBLIN_OUTPUT_DIR").unwrap();
+        let transient_0_output_dir = PathBuf::from(output_dir).join("transient-0");
+        std::fs::create_dir_all(&transient_0_output_dir).unwrap();
+        let transient_0_output_path = transient_0_output_dir.join(name);
+        std::fs::write(transient_0_output_path, bytes.get_ref()).unwrap();
+
+        bytes.set_position(0);
+        let decoded_value = decode(&mut bytes, &mut Vec::new()).unwrap();
+
+        assert_eq!(value, decoded_value);
+
+        decoded_value
+    }
+}