summaryrefslogtreecommitdiff
path: root/serde_dhall/tests
diff options
context:
space:
mode:
Diffstat (limited to 'serde_dhall/tests')
-rw-r--r--serde_dhall/tests/de.rs150
-rw-r--r--serde_dhall/tests/serde.rs210
-rw-r--r--serde_dhall/tests/simple_value.rs58
3 files changed, 268 insertions, 150 deletions
diff --git a/serde_dhall/tests/de.rs b/serde_dhall/tests/de.rs
deleted file mode 100644
index 3abaad2..0000000
--- a/serde_dhall/tests/de.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use serde::Deserialize;
-use serde_dhall::{from_str, FromDhall, NumKind, SimpleValue, StaticType};
-
-#[test]
-fn test_de_typed() {
- fn parse<T: FromDhall + StaticType>(s: &str) -> T {
- from_str(s).static_type_annotation().parse().unwrap()
- }
-
- assert_eq!(parse::<bool>("True"), true);
-
- assert_eq!(parse::<u64>("1"), 1);
- assert_eq!(parse::<u32>("1"), 1);
- assert_eq!(parse::<usize>("1"), 1);
-
- assert_eq!(parse::<i64>("+1"), 1);
- assert_eq!(parse::<i32>("+1"), 1);
- assert_eq!(parse::<isize>("+1"), 1);
-
- assert_eq!(parse::<f64>("1.0"), 1.0);
- assert_eq!(parse::<f32>("1.0"), 1.0);
-
- assert_eq!(parse::<String>(r#""foo""#), "foo".to_owned());
- assert_eq!(parse::<Vec<u64>>("[] : List Natural"), <Vec<u64>>::new());
- assert_eq!(parse::<Vec<u64>>("[1, 2]"), vec![1, 2]);
- assert_eq!(parse::<Option<u64>>("None Natural"), None);
- assert_eq!(parse::<Option<u64>>("Some 1"), Some(1));
-
- assert_eq!(
- parse::<(u64, String)>(r#"{ _1 = 1, _2 = "foo" }"#),
- (1, "foo".to_owned())
- );
-
- #[derive(Debug, PartialEq, Eq, Deserialize, StaticType)]
- struct Foo {
- x: u64,
- y: i64,
- }
- assert_eq!(parse::<Foo>("{ x = 1, y = -2 }"), Foo { x: 1, y: -2 });
-
- #[derive(Debug, PartialEq, Eq, Deserialize, StaticType)]
- enum Bar {
- X(u64),
- Y(i64),
- }
- assert_eq!(parse::<Bar>("< X: Natural | Y: Integer >.X 1"), Bar::X(1));
-
- #[derive(Debug, PartialEq, Eq, Deserialize, StaticType)]
- enum Baz {
- X,
- Y(i64),
- }
- assert_eq!(parse::<Baz>("< X | Y: Integer >.X"), Baz::X);
-
- assert!(from_str("< X | Y: Integer >.Y")
- .static_type_annotation()
- .parse::<Baz>()
- .is_err());
-}
-
-#[test]
-fn test_de_untyped() {
- use std::collections::BTreeMap;
- use std::collections::HashMap;
-
- fn parse<T: FromDhall>(s: &str) -> T {
- from_str(s).parse().unwrap()
- }
-
- // Test tuples on record of wrong type
- assert_eq!(
- parse::<(u64, String, i64)>(r#"{ y = "foo", x = 1, z = +42 }"#),
- (1, "foo".to_owned(), 42)
- );
-
- let mut expected_map = HashMap::new();
- expected_map.insert("x".to_string(), 1);
- expected_map.insert("y".to_string(), 2);
- assert_eq!(
- parse::<HashMap<String, u64>>("{ x = 1, y = 2 }"),
- expected_map
- );
- assert_eq!(
- parse::<HashMap<String, u64>>("toMap { x = 1, y = 2 }"),
- expected_map
- );
-
- let mut expected_map = HashMap::new();
- expected_map.insert("if".to_string(), 1);
- expected_map.insert("FOO_BAR".to_string(), 2);
- expected_map.insert("baz-kux".to_string(), 3);
- assert_eq!(
- parse::<HashMap<String, u64>>("{ `if` = 1, FOO_BAR = 2, baz-kux = 3 }"),
- expected_map
- );
-
- let mut expected_map = BTreeMap::new();
- expected_map.insert("x".to_string(), 1);
- expected_map.insert("y".to_string(), 2);
- assert_eq!(
- parse::<BTreeMap<String, u64>>("{ x = 1, y = 2 }"),
- expected_map
- );
-
- #[derive(Debug, PartialEq, Eq, Deserialize)]
- struct Foo {
- x: u64,
- y: Option<u64>,
- }
- // Omit optional field
- assert_eq!(parse::<Foo>("{ x = 1 }"), Foo { x: 1, y: None });
-
- // https://github.com/Nadrieril/dhall-rust/issues/155
- 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
new file mode 100644
index 0000000..4c184e7
--- /dev/null
+++ b/serde_dhall/tests/serde.rs
@@ -0,0 +1,210 @@
+mod serde {
+ use serde::{Deserialize, Serialize};
+ use serde_dhall::{from_str, serialize, FromDhall, StaticType, ToDhall};
+
+ fn assert_de<T>(s: &str, x: T)
+ where
+ T: FromDhall + StaticType + PartialEq + std::fmt::Debug,
+ {
+ assert_eq!(
+ from_str(s)
+ .static_type_annotation()
+ .parse::<T>()
+ .map_err(|e| e.to_string()),
+ Ok(x)
+ );
+ }
+ fn assert_ser<T>(s: &str, x: T)
+ where
+ T: ToDhall + StaticType + PartialEq + std::fmt::Debug,
+ {
+ assert_eq!(
+ serialize(&x)
+ .static_type_annotation()
+ .to_string()
+ .map_err(|e| e.to_string()),
+ Ok(s.to_string())
+ );
+ }
+ fn assert_serde<T>(s: &str, x: T)
+ where
+ T: ToDhall
+ + FromDhall
+ + StaticType
+ + PartialEq
+ + std::fmt::Debug
+ + Clone,
+ {
+ assert_de(s, x.clone());
+ assert_ser(s, x);
+ }
+
+ #[test]
+ fn numbers() {
+ assert_serde("True", true);
+
+ assert_serde("1", 1u64);
+ assert_serde("1", 1u32);
+ assert_serde("1", 1usize);
+
+ assert_serde("+1", 1i64);
+ assert_serde("+1", 1i32);
+ assert_serde("+1", 1isize);
+
+ assert_serde("1.0", 1.0f64);
+ assert_serde("1.0", 1.0f32);
+ }
+
+ #[test]
+ fn text() {
+ assert_serde(r#""foo""#, "foo".to_owned());
+ assert_ser(r#""foo""#, "foo");
+ }
+
+ #[test]
+ fn list() {
+ assert_serde("[] : List Natural", <Vec<u64>>::new());
+ assert_serde("[] : List Text", <Vec<String>>::new());
+ assert_serde(
+ r#"["foo", "bar"]"#,
+ vec!["foo".to_owned(), "bar".to_owned()],
+ );
+ assert_ser(r#"["foo", "bar"]"#, vec!["foo", "bar"]);
+ assert_serde::<Vec<u64>>("[1, 2]", vec![1, 2]);
+ }
+
+ #[test]
+ fn optional() {
+ 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]
+ fn tuple() {
+ assert_serde::<()>(r#"{=}"#, ());
+ assert_serde::<(u64, String)>(
+ r#"{ _1 = 1, _2 = "foo" }"#,
+ (1, "foo".to_owned()),
+ );
+ assert_serde::<(u64, u64, u64, u64)>(
+ r#"{ _1 = 1, _2 = 2, _3 = 3, _4 = 4 }"#,
+ (1, 2, 3, 4),
+ );
+ }
+
+ #[test]
+ fn structs() {
+ // #[derive(
+ // Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+ // )]
+ // struct Foo;
+ // assert_serde::<Foo>("{=}", Foo);
+
+ // #[derive(
+ // Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+ // )]
+ // struct Bar(u64);
+ // assert_serde::<Bar>("{ _1 = 1 }", Bar (1));
+
+ #[derive(
+ Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+ )]
+ struct Baz {
+ x: u64,
+ y: i64,
+ }
+ assert_serde::<Baz>("{ x = 1, y = -2 }", Baz { x: 1, y: -2 });
+ }
+
+ #[test]
+ fn enums() {
+ #[derive(
+ Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+ )]
+ enum Foo {
+ X(u64),
+ Y(i64),
+ }
+ assert_serde::<Foo>("< X: Natural | Y: Integer >.X 1", Foo::X(1));
+
+ #[derive(
+ Debug, Clone, PartialEq, Eq, Deserialize, Serialize, StaticType,
+ )]
+ enum Bar {
+ X,
+ Y(i64),
+ }
+ assert_serde::<Bar>("< X | Y: Integer >.X", Bar::X);
+
+ assert!(from_str("< X | Y: Integer >.Y")
+ .static_type_annotation()
+ .parse::<Bar>()
+ .is_err());
+ }
+
+ #[test]
+ fn test_de_untyped() {
+ use std::collections::BTreeMap;
+ use std::collections::HashMap;
+
+ fn parse<T: FromDhall>(s: &str) -> T {
+ from_str(s).parse().unwrap()
+ }
+
+ // Test tuples on record of wrong type. Fields are just taken in alphabetic order.
+ assert_eq!(
+ parse::<(u64, String, i64)>(r#"{ y = "foo", x = 1, z = +42 }"#),
+ (1, "foo".to_owned(), 42)
+ );
+
+ let mut expected_map = HashMap::new();
+ expected_map.insert("x".to_string(), 1);
+ expected_map.insert("y".to_string(), 2);
+ assert_eq!(
+ parse::<HashMap<String, u64>>("{ x = 1, y = 2 }"),
+ expected_map
+ );
+ assert_eq!(
+ parse::<HashMap<String, u64>>("toMap { x = 1, y = 2 }"),
+ expected_map
+ );
+
+ let mut expected_map = HashMap::new();
+ expected_map.insert("if".to_string(), 1);
+ expected_map.insert("FOO_BAR".to_string(), 2);
+ expected_map.insert("baz-kux".to_string(), 3);
+ assert_eq!(
+ parse::<HashMap<String, u64>>(
+ "{ `if` = 1, FOO_BAR = 2, baz-kux = 3 }"
+ ),
+ expected_map
+ );
+
+ let mut expected_map = BTreeMap::new();
+ expected_map.insert("x".to_string(), 1);
+ expected_map.insert("y".to_string(), 2);
+ assert_eq!(
+ parse::<BTreeMap<String, u64>>("{ x = 1, y = 2 }"),
+ expected_map
+ );
+
+ #[derive(Debug, PartialEq, Eq, Deserialize)]
+ struct Foo {
+ x: u64,
+ y: Option<u64>,
+ }
+ // Omit optional field
+ assert_eq!(parse::<Foo>("{ x = 1 }"), Foo { x: 1, y: None });
+
+ // https://github.com/Nadrieril/dhall-rust/issues/155
+ assert!(from_str("List/length [True, 42]").parse::<bool>().is_err());
+ }
+
+ // TODO: test various builder configurations
+ // In particular test cloning and reusing builder
+}
diff --git a/serde_dhall/tests/simple_value.rs b/serde_dhall/tests/simple_value.rs
new file mode 100644
index 0000000..3bd9d64
--- /dev/null
+++ b/serde_dhall/tests/simple_value.rs
@@ -0,0 +1,58 @@
+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::Union("Foo".into(), None)).to_string().map_err(|e| e.to_string()),
+ Err("cannot serialize value without a type annotation: Union(\"Foo\", None)".to_string())
+ );
+
+ #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+ struct Foo {
+ foo: SimpleValue,
+ }
+ assert_serde(
+ "{ foo = True }",
+ Foo {
+ foo: bool_true.clone(),
+ },
+ );
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-24 17:10:05 +0000