summaryrefslogtreecommitdiff
path: root/serde_dhall/tests
diff options
context:
space:
mode:
Diffstat (limited to 'serde_dhall/tests')
-rw-r--r--serde_dhall/tests/de.rs34
-rw-r--r--serde_dhall/tests/serde.rs8
-rw-r--r--serde_dhall/tests/simple_value.rs57
3 files changed, 64 insertions, 35 deletions
diff --git a/serde_dhall/tests/de.rs b/serde_dhall/tests/de.rs
index 0b43de2..f49bee4 100644
--- a/serde_dhall/tests/de.rs
+++ b/serde_dhall/tests/de.rs
@@ -1,5 +1,5 @@
use serde::Deserialize;
-use serde_dhall::{from_str, FromDhall, NumKind, SimpleValue};
+use serde_dhall::{from_str, FromDhall};
#[test]
fn test_de_untyped() {
@@ -57,37 +57,5 @@ fn test_de_untyped() {
assert!(from_str("List/length [True, 42]").parse::<bool>().is_err());
}
-#[test]
-fn test_de_simplevalue() {
- let bool_true = SimpleValue::Num(NumKind::Bool(true));
- // https://github.com/Nadrieril/dhall-rust/issues/184
- assert_eq!(
- from_str("[ True ]").parse::<Vec<SimpleValue>>().unwrap(),
- vec![bool_true.clone()]
- );
-
- assert_eq!(
- from_str("< Foo >.Foo").parse::<SimpleValue>().unwrap(),
- SimpleValue::Union("Foo".into(), None)
- );
- assert_eq!(
- from_str("< Foo: Bool >.Foo True")
- .parse::<SimpleValue>()
- .unwrap(),
- SimpleValue::Union("Foo".into(), Some(Box::new(bool_true.clone())))
- );
-
- #[derive(Debug, PartialEq, Eq, Deserialize)]
- struct Foo {
- foo: SimpleValue,
- }
- assert_eq!(
- from_str("{ foo = True }").parse::<Foo>().unwrap(),
- Foo {
- foo: bool_true.clone()
- },
- );
-}
-
// TODO: test various builder configurations
// In particular test cloning and reusing builder
diff --git a/serde_dhall/tests/serde.rs b/serde_dhall/tests/serde.rs
index 39f2f79..ce25380 100644
--- a/serde_dhall/tests/serde.rs
+++ b/serde_dhall/tests/serde.rs
@@ -75,9 +75,13 @@ mod serde {
#[test]
fn optional() {
- assert_serde::<Option<u64>>("None Natural", None);
- assert_serde::<Option<String>>("None Text", None);
+ assert_serde("None Natural", None::<u64>);
+ assert_serde("None Text", None::<String>);
assert_serde("Some 1", Some(1u64));
+ assert_eq!(
+ serialize(&None::<u64>).to_string().map_err(|e| e.to_string()),
+ Err("cannot serialize value without a type annotation: Optional(None)".to_string())
+ );
}
#[test]
diff --git a/serde_dhall/tests/simple_value.rs b/serde_dhall/tests/simple_value.rs
new file mode 100644
index 0000000..d2792d4
--- /dev/null
+++ b/serde_dhall/tests/simple_value.rs
@@ -0,0 +1,57 @@
+mod simple_value {
+ use serde::{Deserialize, Serialize};
+ use serde_dhall::{
+ from_str, serialize, FromDhall, NumKind, SimpleValue, ToDhall,
+ };
+
+ fn assert_de<T>(s: &str, x: T)
+ where
+ T: FromDhall + PartialEq + std::fmt::Debug,
+ {
+ assert_eq!(from_str(s).parse::<T>().map_err(|e| e.to_string()), Ok(x));
+ }
+ fn assert_ser<T>(s: &str, x: T)
+ where
+ T: ToDhall + PartialEq + std::fmt::Debug,
+ {
+ assert_eq!(
+ serialize(&x).to_string().map_err(|e| e.to_string()),
+ Ok(s.to_string())
+ );
+ }
+ fn assert_serde<T>(s: &str, x: T)
+ where
+ T: ToDhall + FromDhall + PartialEq + std::fmt::Debug + Clone,
+ {
+ assert_de(s, x.clone());
+ assert_ser(s, x);
+ }
+
+ #[test]
+ fn test_serde() {
+ let bool_true = SimpleValue::Num(NumKind::Bool(true));
+ // https://github.com/Nadrieril/dhall-rust/issues/184
+ // assert_serde("[ True ]", vec![bool_true.clone()]);
+ assert_de("< Foo >.Foo", SimpleValue::Union("Foo".into(), None));
+ assert_de(
+ "< Foo: Bool >.Foo True",
+ SimpleValue::Union("Foo".into(), Some(Box::new(bool_true.clone()))),
+ );
+
+ // assert_eq!(
+ // serialize(&SimpleValue::Optional(None)).to_string().map_err(|e| e.to_string()),
+ // Err("cannot serialize value without a type annotation: Optional(None)".to_string())
+ // );
+
+ // #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+ // struct Foo {
+ // foo: SimpleValue,
+ // }
+ // assert_serde(
+ // "{ foo = True }",
+ // Foo {
+ // foo: bool_true.clone(),
+ // },
+ // );
+ }
+}