port tests over as well (#450)

Byron · Byron · commit 9b28df22b858 · 2022-08-29T22:18:48.000+08:00
diff --git a/Makefile b/Makefile
@@ -108,6 +108,8 @@ check: ## Build all code in suitable configurations
 			   && cargo check --features cache-efficiency-debug
 	cd git-commitgraph && cargo check --all-features \
 			   && cargo check
+	cd git-config-value && cargo check --all-features \
+				 && cargo check
 	cd git-config && cargo check --all-features \
 				 && cargo check
 	cd git-transport && cargo check \
diff --git a/git-config-value/tests/value/boolean.rs b/git-config-value/tests/value/boolean.rs
@@ -0,0 +1,40 @@
+use crate::b;
+use git_config_value::Boolean;
+use std::convert::TryFrom;
+
+#[test]
+fn from_str_false() -> crate::Result {
+    assert!(!Boolean::try_from(b("no"))?.0);
+    assert!(!Boolean::try_from(b("off"))?.0);
+    assert!(!Boolean::try_from(b("false"))?.0);
+    assert!(!Boolean::try_from(b("0"))?.0);
+    assert!(!Boolean::try_from(b(""))?.0);
+    Ok(())
+}
+
+#[test]
+fn from_str_true() -> crate::Result {
+    assert_eq!(Boolean::try_from(b("yes")).map(Into::into), Ok(true));
+    assert_eq!(Boolean::try_from(b("on")), Ok(Boolean(true)));
+    assert_eq!(Boolean::try_from(b("true")), Ok(Boolean(true)));
+    assert!(Boolean::try_from(b("1"))?.0);
+    assert!(Boolean::try_from(b("+10"))?.0);
+    assert!(Boolean::try_from(b("-1"))?.0);
+    Ok(())
+}
+
+#[test]
+fn ignores_case() {
+    // Random subset
+    for word in &["no", "yes", "on", "off", "true", "false"] {
+        let first: bool = Boolean::try_from(b(word)).unwrap().into();
+        let second: bool = Boolean::try_from(b(&*word.to_uppercase())).unwrap().into();
+        assert_eq!(first, second);
+    }
+}
+
+#[test]
+fn from_str_err() {
+    assert!(Boolean::try_from(b("yesn't")).is_err());
+    assert!(Boolean::try_from(b("yesno")).is_err());
+}
diff --git a/git-config-value/tests/value/color.rs b/git-config-value/tests/value/color.rs
@@ -0,0 +1,198 @@
+mod name {
+    use git_config_value::color::Name;
+    use std::str::FromStr;
+
+    #[test]
+    fn non_bright() {
+        assert_eq!(Name::from_str("normal"), Ok(Name::Normal));
+        assert_eq!(Name::from_str("-1"), Ok(Name::Normal));
+        assert_eq!(Name::from_str("default"), Ok(Name::Default));
+        assert_eq!(Name::from_str("black"), Ok(Name::Black));
+        assert_eq!(Name::from_str("red"), Ok(Name::Red));
+        assert_eq!(Name::from_str("green"), Ok(Name::Green));
+        assert_eq!(Name::from_str("yellow"), Ok(Name::Yellow));
+        assert_eq!(Name::from_str("blue"), Ok(Name::Blue));
+        assert_eq!(Name::from_str("magenta"), Ok(Name::Magenta));
+        assert_eq!(Name::from_str("cyan"), Ok(Name::Cyan));
+        assert_eq!(Name::from_str("white"), Ok(Name::White));
+    }
+
+    #[test]
+    fn bright() {
+        assert_eq!(Name::from_str("brightblack"), Ok(Name::BrightBlack));
+        assert_eq!(Name::from_str("brightred"), Ok(Name::BrightRed));
+        assert_eq!(Name::from_str("brightgreen"), Ok(Name::BrightGreen));
+        assert_eq!(Name::from_str("brightyellow"), Ok(Name::BrightYellow));
+        assert_eq!(Name::from_str("brightblue"), Ok(Name::BrightBlue));
+        assert_eq!(Name::from_str("brightmagenta"), Ok(Name::BrightMagenta));
+        assert_eq!(Name::from_str("brightcyan"), Ok(Name::BrightCyan));
+        assert_eq!(Name::from_str("brightwhite"), Ok(Name::BrightWhite));
+    }
+
+    #[test]
+    fn ansi() {
+        assert_eq!(Name::from_str("255"), Ok(Name::Ansi(255)));
+        assert_eq!(Name::from_str("0"), Ok(Name::Ansi(0)));
+    }
+
+    #[test]
+    fn hex() {
+        assert_eq!(Name::from_str("#ff0010"), Ok(Name::Rgb(255, 0, 16)));
+        assert_eq!(Name::from_str("#ffffff"), Ok(Name::Rgb(255, 255, 255)));
+        assert_eq!(Name::from_str("#000000"), Ok(Name::Rgb(0, 0, 0)));
+    }
+
+    #[test]
+    fn invalid() {
+        assert!(Name::from_str("-2").is_err());
+        assert!(Name::from_str("brightnormal").is_err());
+        assert!(Name::from_str("brightdefault").is_err());
+        assert!(Name::from_str("").is_err());
+        assert!(Name::from_str("bright").is_err());
+        assert!(Name::from_str("256").is_err());
+        assert!(Name::from_str("#").is_err());
+        assert!(Name::from_str("#fff").is_err());
+        assert!(Name::from_str("#gggggg").is_err());
+    }
+}
+
+mod attribute {
+    use std::str::FromStr;
+
+    use git_config_value::color::Attribute;
+
+    #[test]
+    fn non_inverted() {
+        assert_eq!(Attribute::from_str("reset"), Ok(Attribute::RESET));
+        assert_eq!(Attribute::from_str("bold"), Ok(Attribute::BOLD));
+        assert_eq!(Attribute::from_str("dim"), Ok(Attribute::DIM));
+        assert_eq!(Attribute::from_str("ul"), Ok(Attribute::UL));
+        assert_eq!(Attribute::from_str("blink"), Ok(Attribute::BLINK));
+        assert_eq!(Attribute::from_str("reverse"), Ok(Attribute::REVERSE));
+        assert_eq!(Attribute::from_str("italic"), Ok(Attribute::ITALIC));
+        assert_eq!(Attribute::from_str("strike"), Ok(Attribute::STRIKE));
+    }
+
+    #[test]
+    fn inverted_no_dash() {
+        assert_eq!(Attribute::from_str("nobold"), Ok(Attribute::NO_BOLD));
+        assert_eq!(Attribute::from_str("nodim"), Ok(Attribute::NO_DIM));
+        assert_eq!(Attribute::from_str("noul"), Ok(Attribute::NO_UL));
+        assert_eq!(Attribute::from_str("noblink"), Ok(Attribute::NO_BLINK));
+        assert_eq!(Attribute::from_str("noreverse"), Ok(Attribute::NO_REVERSE));
+        assert_eq!(Attribute::from_str("noitalic"), Ok(Attribute::NO_ITALIC));
+        assert_eq!(Attribute::from_str("nostrike"), Ok(Attribute::NO_STRIKE));
+    }
+
+    #[test]
+    fn inverted_dashed() {
+        assert_eq!(Attribute::from_str("no-bold"), Ok(Attribute::NO_BOLD));
+        assert_eq!(Attribute::from_str("no-dim"), Ok(Attribute::NO_DIM));
+        assert_eq!(Attribute::from_str("no-ul"), Ok(Attribute::NO_UL));
+        assert_eq!(Attribute::from_str("no-blink"), Ok(Attribute::NO_BLINK));
+        assert_eq!(Attribute::from_str("no-reverse"), Ok(Attribute::NO_REVERSE));
+        assert_eq!(Attribute::from_str("no-italic"), Ok(Attribute::NO_ITALIC));
+        assert_eq!(Attribute::from_str("no-strike"), Ok(Attribute::NO_STRIKE));
+    }
+
+    #[test]
+    fn invalid() {
+        assert!(Attribute::from_str("no-reset").is_err());
+        assert!(Attribute::from_str("noreset").is_err());
+        assert!(Attribute::from_str("a").is_err());
+        assert!(Attribute::from_str("no bold").is_err());
+        assert!(Attribute::from_str("").is_err());
+        assert!(Attribute::from_str("no").is_err());
+        assert!(Attribute::from_str("no-").is_err());
+    }
+}
+
+mod from_git {
+    use std::convert::TryFrom;
+
+    use bstr::BStr;
+    use git_config_value::Color;
+
+    #[test]
+    fn reset() {
+        assert_eq!(color("reset"), "reset");
+    }
+
+    #[test]
+    fn empty() {
+        assert_eq!(color(""), "");
+    }
+
+    #[test]
+    fn at_most_two_colors() {
+        assert!(try_color("red green blue").is_err());
+    }
+
+    #[test]
+    fn attribute_before_color_name() {
+        assert_eq!(color("bold red"), "red bold");
+    }
+
+    #[test]
+    fn color_name_before_attribute() {
+        assert_eq!(color("red bold"), "red bold");
+    }
+
+    #[test]
+    fn attribute_fg_bg() {
+        assert_eq!(color("ul blue red"), "blue red ul");
+    }
+
+    #[test]
+    fn fg_bg_attribute() {
+        assert_eq!(color("blue red ul"), "blue red ul");
+    }
+
+    #[test]
+    fn multiple_attributes() {
+        assert_eq!(
+            color("blue bold dim ul blink reverse"),
+            "blue bold dim ul blink reverse"
+        );
+    }
+
+    #[test]
+    fn reset_then_multiple_attributes() {
+        assert_eq!(
+            color("blue bold dim ul blink reverse reset"),
+            "blue bold dim ul blink reverse reset"
+        );
+    }
+
+    #[test]
+    fn long_color_spec() {
+        assert_eq!(
+            color("254 255 bold dim ul blink reverse"),
+            "254 255 bold dim ul blink reverse"
+        );
+        let input = "#ffffff #ffffff bold nobold dim nodim italic noitalic ul noul blink noblink reverse noreverse strike nostrike";
+        let expected = "#ffffff #ffffff bold dim italic ul blink reverse strike nodim nobold noitalic noul noblink noreverse nostrike";
+        assert_eq!(color(input), expected);
+    }
+
+    #[test]
+    fn normal_default_can_clear_backgrounds() {
+        assert_eq!(color("normal default"), "normal default");
+    }
+
+    #[test]
+    fn default_can_combine_with_attributes() {
+        assert_eq!(
+            color("default default no-reverse bold"),
+            "default default bold noreverse"
+        );
+    }
+
+    fn color<'a>(name: impl Into<&'a BStr>) -> String {
+        try_color(name).expect("input color is expected to be valid")
+    }
+
+    fn try_color<'a>(name: impl Into<&'a BStr>) -> crate::Result<String> {
+        Ok(Color::try_from(name.into())?.to_string())
+    }
+}
diff --git a/git-config-value/tests/value/integer.rs b/git-config-value/tests/value/integer.rs
@@ -0,0 +1,74 @@
+use std::convert::TryFrom;
+
+use crate::b;
+use git_config_value::integer::Suffix;
+use git_config_value::Integer;
+
+#[test]
+fn from_str_no_suffix() {
+    assert_eq!(Integer::try_from(b("1")).unwrap(), Integer { value: 1, suffix: None });
+
+    assert_eq!(
+        Integer::try_from(b("-1")).unwrap(),
+        Integer {
+            value: -1,
+            suffix: None
+        }
+    );
+}
+
+#[test]
+fn from_str_with_suffix() {
+    assert_eq!(
+        Integer::try_from(b("1k")).unwrap(),
+        Integer {
+            value: 1,
+            suffix: Some(Suffix::Kibi),
+        }
+    );
+
+    assert_eq!(
+        Integer::try_from(b("1m")).unwrap(),
+        Integer {
+            value: 1,
+            suffix: Some(Suffix::Mebi),
+        }
+    );
+
+    assert_eq!(
+        Integer::try_from(b("1g")).unwrap(),
+        Integer {
+            value: 1,
+            suffix: Some(Suffix::Gibi),
+        }
+    );
+}
+
+#[test]
+fn invalid_from_str() {
+    assert!(Integer::try_from(b("")).is_err());
+    assert!(Integer::try_from(b("-")).is_err());
+    assert!(Integer::try_from(b("k")).is_err());
+    assert!(Integer::try_from(b("m")).is_err());
+    assert!(Integer::try_from(b("g")).is_err());
+    assert!(Integer::try_from(b("123123123123123123123123")).is_err());
+    assert!(Integer::try_from(b("gg")).is_err());
+}
+
+#[test]
+fn as_decimal() {
+    fn decimal(input: &str) -> Option<i64> {
+        Integer::try_from(b(input)).unwrap().to_decimal()
+    }
+
+    assert_eq!(decimal("12"), Some(12), "works without suffix");
+    assert_eq!(decimal("13k"), Some(13 * 1024), "works with kilobyte suffix");
+    assert_eq!(decimal("13K"), Some(13 * 1024), "works with Kilobyte suffix");
+    assert_eq!(decimal("14m"), Some(14 * 1_048_576), "works with megabyte suffix");
+    assert_eq!(decimal("14M"), Some(14 * 1_048_576), "works with Megabyte suffix");
+    assert_eq!(decimal("15g"), Some(15 * 1_073_741_824), "works with gigabyte suffix");
+    assert_eq!(decimal("15G"), Some(15 * 1_073_741_824), "works with Gigabyte suffix");
+
+    assert_eq!(decimal(&format!("{}g", i64::MAX)), None, "overflow results in None");
+    assert_eq!(decimal(&format!("{}g", i64::MIN)), None, "underflow results in None");
+}
diff --git a/git-config-value/tests/value/main.rs b/git-config-value/tests/value/main.rs
@@ -0,0 +1,16 @@
+use bstr::{BStr, ByteSlice};
+use std::borrow::Cow;
+
+type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
+fn b(s: &str) -> &bstr::BStr {
+    s.into()
+}
+
+pub fn cow_str(s: &str) -> Cow<'_, BStr> {
+    Cow::Borrowed(s.as_bytes().as_bstr())
+}
+
+mod boolean;
+mod color;
+mod integer;
+mod path;
diff --git a/git-config-value/tests/value/path.rs b/git-config-value/tests/value/path.rs
diff --git a/git-config/tests/value/mod.rs b/git-config/tests/value/mod.rs
