From 39ef66b77bc2431ce074010f9281efdb4d885acf Mon Sep 17 00:00:00 2001 From: Pantonshire Date: Fri, 21 May 2021 15:53:37 +0100 Subject: [PATCH] Tests --- enumscribe/Cargo.toml | 8 +- enumscribe_tests/Cargo.toml | 5 +- enumscribe_tests/tests/test_scribe.rs | 295 ++++++++++++++++++++++++ enumscribe_tests/tests/test_serde.rs | 1 + enumscribe_tests/tests/test_unscribe.rs | 0 5 files changed, 306 insertions(+), 3 deletions(-) create mode 100644 enumscribe_tests/tests/test_scribe.rs create mode 100644 enumscribe_tests/tests/test_serde.rs create mode 100644 enumscribe_tests/tests/test_unscribe.rs diff --git a/enumscribe/Cargo.toml b/enumscribe/Cargo.toml index fc8801e..68ac1a5 100644 --- a/enumscribe/Cargo.toml +++ b/enumscribe/Cargo.toml @@ -11,7 +11,11 @@ description = "Procedural macros for converting between enums and strings" [dependencies] enumscribe_derive = { version = "0.1.0", path = "../enumscribe_derive", optional = true } +[dev-dependencies] +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" + [features] -default = ["derive", "serde"] +default = ["derive", "derive_serde"] derive = ["enumscribe_derive"] -serde = ["derive", "enumscribe_derive/serde"] +derive_serde = ["derive", "enumscribe_derive/serde"] diff --git a/enumscribe_tests/Cargo.toml b/enumscribe_tests/Cargo.toml index 9bde18c..4f6fff3 100644 --- a/enumscribe_tests/Cargo.toml +++ b/enumscribe_tests/Cargo.toml @@ -5,4 +5,7 @@ authors = ["Tom Panton "] edition = "2018" license = "MIT" -[dependencies] +[dev-dependencies] +enumscribe = { path = "../enumscribe" } +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" diff --git a/enumscribe_tests/tests/test_scribe.rs b/enumscribe_tests/tests/test_scribe.rs new file mode 100644 index 0000000..c893376 --- /dev/null +++ b/enumscribe_tests/tests/test_scribe.rs @@ -0,0 +1,295 @@ +use std::borrow::Cow; + +use enumscribe::{ + ScribeCowStr, + ScribeStaticStr, + ScribeString, + TryScribeCowStr, + TryScribeStaticStr, + TryScribeString, +}; + +const TEST_STRINGS: [&'static str; 6] = [ + "", "\0", "foo", "baa", "Hello, world!", "こんにちは、世界" +]; + +#[test] +fn test_scribe_static_str() { + #[derive(ScribeStaticStr, Eq, PartialEq, Debug)] + enum E0 { + V0, + #[enumscribe(str = "foo")] + V1, + V2(), + #[enumscribe(str = "baa")] + V3(), + V4 {}, + #[enumscribe(str = "baz")] + V5 {}, + } + + assert_eq!(E0::V0.scribe(), "V0"); + assert_eq!(E0::V1.scribe(), "foo"); + assert_eq!(E0::V2().scribe(), "V2"); + assert_eq!(E0::V3().scribe(), "baa"); + assert_eq!(E0::V4 {}.scribe(), "V4"); + assert_eq!(E0::V5 {}.scribe(), "baz"); +} + +#[test] +fn test_try_scribe_static_str() { + #[derive(TryScribeStaticStr, Eq, PartialEq, Debug)] + enum E0 { + V0, + #[enumscribe(str = "foo")] + V1, + V2(), + #[enumscribe(str = "baa")] + V3(), + V4 {}, + #[enumscribe(str = "baz")] + V5 {}, + #[enumscribe(ignore)] + V6, + #[enumscribe(ignore)] + V7(i32, i32), + #[enumscribe(ignore)] + V8 { s: &'static str, x: i32 }, + } + + assert_eq!(E0::V0.try_scribe(), Some("V0")); + assert_eq!(E0::V1.try_scribe(), Some("foo")); + assert_eq!(E0::V2().try_scribe(), Some("V2")); + assert_eq!(E0::V3().try_scribe(), Some("baa")); + assert_eq!(E0::V4 {}.try_scribe(), Some("V4")); + assert_eq!(E0::V5 {}.try_scribe(), Some("baz")); + assert_eq!(E0::V6.try_scribe(), None); + assert_eq!(E0::V7(123, 456).try_scribe(), None); + assert_eq!(E0::V8 { s: "lorem ipsum", x: 246 }.try_scribe(), None); +} + +#[test] +fn test_scribe_string() { + #[derive(ScribeString, Eq, PartialEq, Debug)] + enum E0 { + V0, + #[enumscribe(str = "foo")] + V1, + V2(), + #[enumscribe(str = "baa")] + V3(), + V4 {}, + #[enumscribe(str = "baz")] + V5 {}, + } + + assert_eq!(E0::V0.scribe(), "V0".to_owned()); + assert_eq!(E0::V1.scribe(), "foo".to_owned()); + assert_eq!(E0::V2().scribe(), "V2".to_owned()); + assert_eq!(E0::V3().scribe(), "baa".to_owned()); + assert_eq!(E0::V4 {}.scribe(), "V4".to_owned()); + assert_eq!(E0::V5 {}.scribe(), "baz".to_owned()); + + #[derive(ScribeString, Eq, PartialEq, Debug)] + enum E1 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1(String), + } + + assert_eq!(E1::V0.scribe(), "foo".to_owned()); + for &x in &TEST_STRINGS { + assert_eq!(E1::V1(x.to_owned()).scribe(), x.to_owned()); + } + + #[derive(ScribeString, Eq, PartialEq, Debug)] + enum E2 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1 { s: String }, + } + + assert_eq!(E2::V0.scribe(), "foo".to_owned()); + for &x in &TEST_STRINGS { + assert_eq!(E2::V1 { s: x.to_owned() }.scribe(), x.to_owned()); + } +} + +#[test] +fn test_try_scribe_string() { + #[derive(TryScribeString, Eq, PartialEq, Debug)] + enum E0 { + V0, + #[enumscribe(str = "foo")] + V1, + V2(), + #[enumscribe(str = "baa")] + V3(), + V4 {}, + #[enumscribe(str = "baz")] + V5 {}, + #[enumscribe(ignore)] + V6, + #[enumscribe(ignore)] + V7(i32, i32), + #[enumscribe(ignore)] + V8 { s: &'static str, x: i32 }, + } + + assert_eq!(E0::V0.try_scribe(), Some("V0".to_owned())); + assert_eq!(E0::V1.try_scribe(), Some("foo".to_owned())); + assert_eq!(E0::V2().try_scribe(), Some("V2".to_owned())); + assert_eq!(E0::V3().try_scribe(), Some("baa".to_owned())); + assert_eq!(E0::V4 {}.try_scribe(), Some("V4".to_owned())); + assert_eq!(E0::V5 {}.try_scribe(), Some("baz".to_owned())); + assert_eq!(E0::V6.try_scribe(), None); + assert_eq!(E0::V7(123, 456).try_scribe(), None); + assert_eq!(E0::V8 { s: "lorem ipsum", x: 246 }.try_scribe(), None); + + #[derive(TryScribeString, Eq, PartialEq, Debug)] + enum E1 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1(String), + #[enumscribe(ignore)] + V2, + } + + assert_eq!(E1::V0.try_scribe(), Some("foo".to_owned())); + for &x in &TEST_STRINGS { + assert_eq!(E1::V1(x.to_owned()).try_scribe(), Some(x.to_owned())); + } + assert_eq!(E1::V2.try_scribe(), None); + + #[derive(TryScribeString, Eq, PartialEq, Debug)] + enum E2 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1 { s: String }, + #[enumscribe(ignore)] + V2, + } + + assert_eq!(E2::V0.try_scribe(), Some("foo".to_owned())); + for &x in &TEST_STRINGS { + assert_eq!(E2::V1 { s: x.to_owned() }.try_scribe(), Some(x.to_owned())); + } + assert_eq!(E2::V2.try_scribe(), None); +} + +#[test] +fn test_scribe_cow_str() { + #[derive(ScribeCowStr, Eq, PartialEq, Debug)] + enum E0 { + V0, + #[enumscribe(str = "foo")] + V1, + V2(), + #[enumscribe(str = "baa")] + V3(), + V4 {}, + #[enumscribe(str = "baz")] + V5 {}, + } + + assert_eq!(E0::V0.scribe(), Cow::Borrowed("V0")); + assert_eq!(E0::V1.scribe(), Cow::Borrowed("foo")); + assert_eq!(E0::V2().scribe(), Cow::Borrowed("V2")); + assert_eq!(E0::V3().scribe(), Cow::Borrowed("baa")); + assert_eq!(E0::V4 {}.scribe(), Cow::Borrowed("V4")); + assert_eq!(E0::V5 {}.scribe(), Cow::Borrowed("baz")); + + #[derive(ScribeCowStr, Eq, PartialEq, Debug)] + enum E1 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1(String), + } + + assert_eq!(E1::V0.scribe(), Cow::Borrowed("foo")); + for &x in &TEST_STRINGS { + assert_eq!(E1::V1(x.to_owned()).scribe(), Cow::Owned::<'static, str>(x.to_owned())); + } + + #[derive(ScribeCowStr, Eq, PartialEq, Debug)] + enum E2 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1 { s: String }, + } + + assert_eq!(E2::V0.scribe(), "foo".to_owned()); + for &x in &TEST_STRINGS { + assert_eq!(E2::V1 { s: x.to_owned() }.scribe(), Cow::Owned::<'static, str>(x.to_owned())); + } +} + +#[test] +fn test_try_scribe_cow_str() { + #[derive(TryScribeCowStr, Eq, PartialEq, Debug)] + enum E0 { + V0, + #[enumscribe(str = "foo")] + V1, + V2(), + #[enumscribe(str = "baa")] + V3(), + V4 {}, + #[enumscribe(str = "baz")] + V5 {}, + #[enumscribe(ignore)] + V6, + #[enumscribe(ignore)] + V7(i32, i32), + #[enumscribe(ignore)] + V8 { s: &'static str, x: i32 }, + } + + assert_eq!(E0::V0.try_scribe(), Some(Cow::Borrowed("V0"))); + assert_eq!(E0::V1.try_scribe(), Some(Cow::Borrowed("foo"))); + assert_eq!(E0::V2().try_scribe(), Some(Cow::Borrowed("V2"))); + assert_eq!(E0::V3().try_scribe(), Some(Cow::Borrowed("baa"))); + assert_eq!(E0::V4 {}.try_scribe(), Some(Cow::Borrowed("V4"))); + assert_eq!(E0::V5 {}.try_scribe(), Some(Cow::Borrowed("baz"))); + assert_eq!(E0::V6.try_scribe(), None); + assert_eq!(E0::V7(123, 456).try_scribe(), None); + assert_eq!(E0::V8 { s: "lorem ipsum", x: 246 }.try_scribe(), None); + + #[derive(TryScribeCowStr, Eq, PartialEq, Debug)] + enum E1 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1(String), + #[enumscribe(ignore)] + V2, + } + + assert_eq!(E1::V0.try_scribe(), Some(Cow::Borrowed("foo"))); + for &x in &TEST_STRINGS { + assert_eq!(E1::V1(x.to_owned()).try_scribe(), Some(Cow::Owned::<'static, str>(x.to_owned()))); + } + assert_eq!(E1::V2.try_scribe(), None); + + #[derive(TryScribeCowStr, Eq, PartialEq, Debug)] + enum E2 { + #[enumscribe(str = "foo")] + V0, + #[enumscribe(other)] + V1 { s: String }, + #[enumscribe(ignore)] + V2, + } + + assert_eq!(E2::V0.try_scribe(), Some(Cow::Borrowed("foo"))); + for &x in &TEST_STRINGS { + assert_eq!(E2::V1 { s: x.to_owned() }.try_scribe(), Some(Cow::Owned::<'static, str>(x.to_owned()))); + } + assert_eq!(E2::V2.try_scribe(), None); +} diff --git a/enumscribe_tests/tests/test_serde.rs b/enumscribe_tests/tests/test_serde.rs new file mode 100644 index 0000000..0b52418 --- /dev/null +++ b/enumscribe_tests/tests/test_serde.rs @@ -0,0 +1 @@ +use serde::{Serialize, Deserialize}; diff --git a/enumscribe_tests/tests/test_unscribe.rs b/enumscribe_tests/tests/test_unscribe.rs new file mode 100644 index 0000000..e69de29