summaryrefslogtreecommitdiff
path: root/serde_dhall/tests
diff options
context:
space:
mode:
authorstuebinm2021-05-02 00:33:31 +0200
committerstuebinm2021-05-02 00:36:45 +0200
commite65c53a8e22e2edf209a31ad28ba67ac5d78bed7 (patch)
tree3d6e17c5e121682e4b409b79dc2eba58494fc570 /serde_dhall/tests
parenta0776173fabe05ed82e0283b55d85a2fffc511bf (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.rs70
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(),