diff options
author | stuebinm | 2021-05-02 00:33:31 +0200 |
---|---|---|
committer | stuebinm | 2021-05-02 00:36:45 +0200 |
commit | e65c53a8e22e2edf209a31ad28ba67ac5d78bed7 (patch) | |
tree | 3d6e17c5e121682e4b409b79dc2eba58494fc570 /serde_dhall/tests | |
parent | a0776173fabe05ed82e0283b55d85a2fffc511bf (diff) |
substitute_names -> inject_types
This does three things:
1. rename the substitute_names function into inject_types, and makes
it accept anything that implements IntoIterator instead of just HashMaps
2. adds an extra function to inject just a single type
3. makes these functions chainable; before, each call to
substitute_names would discard previous invocations. However, this
currently comes at the cost of a lot of ugly copying.
also, more tests!
Diffstat (limited to 'serde_dhall/tests')
-rw-r--r-- | serde_dhall/tests/serde.rs | 70 |
1 files changed, 68 insertions, 2 deletions
diff --git a/serde_dhall/tests/serde.rs b/serde_dhall/tests/serde.rs index 99e4b8b..abf78e3 100644 --- a/serde_dhall/tests/serde.rs +++ b/serde_dhall/tests/serde.rs @@ -151,7 +151,73 @@ mod serde { } #[test] - fn substitutions() { + fn inject_single_type() { + #[derive(Debug, Clone, Deserialize, Serialize, StaticType, Eq, PartialEq)] + enum Foo { + X(u64), + Y(i64), + } + + assert_eq!(from_str("Foo.X 1") + .inject_single_type("Foo".to_string(), Foo::static_type()) + .static_type_annotation() + .parse::<Foo>() + .unwrap(), + Foo::X(1) + ) + } + + #[test] + fn chain_inject_type() { + #[derive(Debug, Clone, Deserialize, Serialize, StaticType, Eq, PartialEq)] + enum Bar { + A,B + } + #[derive(Debug, Clone, Deserialize, Serialize, StaticType, Eq, PartialEq)] + enum Foo { + X(Bar), + Y(i64), + } + + assert_eq!(from_str("Foo.X Bar.A") + .inject_single_type("Bar".to_string(), Bar::static_type()) + .inject_single_type("Foo".to_string(), Foo::static_type()) + .static_type_annotation() + .parse::<Foo>() + .unwrap(), + Foo::X(Bar::A) + ); + + let mut substs = collections::HashMap::new(); + substs.insert("Foo".to_string(), Foo::static_type()); + + assert_eq!(from_str("Foo.X Bar.A") + .inject_types(substs.clone()) + .inject_single_type("Bar".to_string(), Bar::static_type()) + .static_type_annotation() + .parse::<Foo>() + .unwrap(), + Foo::X(Bar::A) + ); + + + // check that in chained injects, later injects override earlier ones + substs.insert("Bar".to_string(), Foo::static_type()); + + assert_eq!(from_str("Foo.X Bar.A") + .inject_types(substs) + .inject_single_type("Bar".to_string(), Bar::static_type()) + .static_type_annotation() + .parse::<Foo>() + .unwrap(), + Foo::X(Bar::A) + ); + + + + } + #[test] + fn inject_types() { #[derive(Debug, Clone, Deserialize, Serialize, StaticType, Eq, PartialEq)] enum Foo { X(u64), @@ -162,7 +228,7 @@ mod serde { substs.insert("Foo".to_string(), Foo::static_type()); assert_eq!(from_str("Foo.X 1") - .substitute_names(substs) + .inject_types(substs) .static_type_annotation() .parse::<Foo>() .unwrap(), |