|
|
@ -98,6 +98,20 @@ fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
|
|
|
|
"stones" => Ok(NonMetric::Stone),
|
|
|
|
"stones" => Ok(NonMetric::Stone),
|
|
|
|
"st" => Ok(NonMetric::Stone),
|
|
|
|
"st" => Ok(NonMetric::Stone),
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
"short ton" => Ok(NonMetric::ShortTon),
|
|
|
|
|
|
|
|
"short tons" => Ok(NonMetric::ShortTon),
|
|
|
|
|
|
|
|
"US ton" => Ok(NonMetric::ShortTon),
|
|
|
|
|
|
|
|
"US tons" => Ok(NonMetric::ShortTon),
|
|
|
|
|
|
|
|
"us ton" => Ok(NonMetric::ShortTon),
|
|
|
|
|
|
|
|
"us tons" => Ok(NonMetric::ShortTon),
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
"long ton" => Ok(NonMetric::LongTon),
|
|
|
|
|
|
|
|
"long tons" => Ok(NonMetric::LongTon),
|
|
|
|
|
|
|
|
"imperial ton" => Ok(NonMetric::LongTon),
|
|
|
|
|
|
|
|
"imperial tons" => Ok(NonMetric::LongTon),
|
|
|
|
|
|
|
|
"imp ton" => Ok(NonMetric::LongTon),
|
|
|
|
|
|
|
|
"imp tons" => Ok(NonMetric::LongTon),
|
|
|
|
|
|
|
|
|
|
|
|
// Temperature
|
|
|
|
// Temperature
|
|
|
|
"degree Fahrenheit" => Ok(NonMetric::Fahrenheit),
|
|
|
|
"degree Fahrenheit" => Ok(NonMetric::Fahrenheit),
|
|
|
|
"degrees Fahrenheit" => Ok(NonMetric::Fahrenheit),
|
|
|
|
"degrees Fahrenheit" => Ok(NonMetric::Fahrenheit),
|
|
|
@ -282,6 +296,9 @@ fn parse_unit(input: String) -> Result<NonMetric, ParseError> {
|
|
|
|
"us gal" => Ok(NonMetric::USGallon),
|
|
|
|
"us gal" => Ok(NonMetric::USGallon),
|
|
|
|
|
|
|
|
|
|
|
|
// Ambiguous units
|
|
|
|
// Ambiguous units
|
|
|
|
|
|
|
|
"ton" => Err(ParseError::AmbiguousUnit(input, "short", "long")),
|
|
|
|
|
|
|
|
"tons" => Err(ParseError::AmbiguousUnit(input, "short", "long")),
|
|
|
|
|
|
|
|
|
|
|
|
"fluid ounce" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
|
|
|
|
"fluid ounce" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
|
|
|
|
"fluid ounces" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
|
|
|
|
"fluid ounces" => Err(ParseError::AmbiguousUnit(input, "imperial", "US")),
|
|
|
|
"fl oz" => Err(ParseError::AmbiguousUnit(input, "imp", "US")),
|
|
|
|
"fl oz" => Err(ParseError::AmbiguousUnit(input, "imp", "US")),
|
|
|
@ -413,325 +430,346 @@ mod test {
|
|
|
|
#[test]
|
|
|
|
#[test]
|
|
|
|
fn units() {
|
|
|
|
fn units() {
|
|
|
|
// Length
|
|
|
|
// Length
|
|
|
|
assert_eq!(parse_unit("inch".to_string()), Ok(NonMetric::Inch));
|
|
|
|
test_units(NonMetric::Inch, &[
|
|
|
|
assert_eq!(parse_unit("inches".to_string()), Ok(NonMetric::Inch));
|
|
|
|
"inch",
|
|
|
|
assert_eq!(parse_unit("in".to_string()), Ok(NonMetric::Inch));
|
|
|
|
"inches",
|
|
|
|
assert_eq!(parse_unit("\"".to_string()), Ok(NonMetric::Inch));
|
|
|
|
"in",
|
|
|
|
assert_eq!(parse_unit("″".to_string()), Ok(NonMetric::Inch));
|
|
|
|
"\"",
|
|
|
|
|
|
|
|
"″",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("foot".to_string()), Ok(NonMetric::Foot));
|
|
|
|
test_units(NonMetric::Foot, &[
|
|
|
|
assert_eq!(parse_unit("feet".to_string()), Ok(NonMetric::Foot));
|
|
|
|
"foot",
|
|
|
|
assert_eq!(parse_unit("ft".to_string()), Ok(NonMetric::Foot));
|
|
|
|
"feet",
|
|
|
|
assert_eq!(parse_unit("'".to_string()), Ok(NonMetric::Foot));
|
|
|
|
"ft",
|
|
|
|
assert_eq!(parse_unit("′".to_string()), Ok(NonMetric::Foot));
|
|
|
|
"'",
|
|
|
|
|
|
|
|
"′",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("yard".to_string()), Ok(NonMetric::Yard));
|
|
|
|
test_units(NonMetric::Yard, &[
|
|
|
|
assert_eq!(parse_unit("yards".to_string()), Ok(NonMetric::Yard));
|
|
|
|
"yard",
|
|
|
|
assert_eq!(parse_unit("yd".to_string()), Ok(NonMetric::Yard));
|
|
|
|
"yards",
|
|
|
|
|
|
|
|
"yd",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("mile".to_string()), Ok(NonMetric::Mile));
|
|
|
|
test_units(NonMetric::Mile, &[
|
|
|
|
assert_eq!(parse_unit("miles".to_string()), Ok(NonMetric::Mile));
|
|
|
|
"mile",
|
|
|
|
assert_eq!(parse_unit("mi".to_string()), Ok(NonMetric::Mile));
|
|
|
|
"miles",
|
|
|
|
assert_eq!(parse_unit("m".to_string()), Ok(NonMetric::Mile));
|
|
|
|
"mi",
|
|
|
|
|
|
|
|
"m",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
// Weight
|
|
|
|
// Weight
|
|
|
|
assert_eq!(parse_unit("ounce".to_string()), Ok(NonMetric::Ounce));
|
|
|
|
test_units(NonMetric::Ounce, &[
|
|
|
|
assert_eq!(parse_unit("ounces".to_string()), Ok(NonMetric::Ounce));
|
|
|
|
"ounce",
|
|
|
|
assert_eq!(parse_unit("oz".to_string()), Ok(NonMetric::Ounce));
|
|
|
|
"ounces",
|
|
|
|
|
|
|
|
"oz",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("pound".to_string()), Ok(NonMetric::Pound));
|
|
|
|
test_units(NonMetric::Pound, &[
|
|
|
|
assert_eq!(parse_unit("pounds".to_string()), Ok(NonMetric::Pound));
|
|
|
|
"pound",
|
|
|
|
assert_eq!(parse_unit("lb".to_string()), Ok(NonMetric::Pound));
|
|
|
|
"pounds",
|
|
|
|
assert_eq!(parse_unit("lbs".to_string()), Ok(NonMetric::Pound));
|
|
|
|
"lb",
|
|
|
|
assert_eq!(parse_unit("#".to_string()), Ok(NonMetric::Pound));
|
|
|
|
"lbs",
|
|
|
|
|
|
|
|
"#",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("stone".to_string()), Ok(NonMetric::Stone));
|
|
|
|
test_units(NonMetric::Stone, &[
|
|
|
|
assert_eq!(parse_unit("stones".to_string()), Ok(NonMetric::Stone));
|
|
|
|
"stone",
|
|
|
|
assert_eq!(parse_unit("st".to_string()), Ok(NonMetric::Stone));
|
|
|
|
"stones",
|
|
|
|
|
|
|
|
"st",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
test_units(NonMetric::ShortTon, &[
|
|
|
|
|
|
|
|
"short ton",
|
|
|
|
|
|
|
|
"short tons",
|
|
|
|
|
|
|
|
"US ton",
|
|
|
|
|
|
|
|
"US tons",
|
|
|
|
|
|
|
|
"us ton",
|
|
|
|
|
|
|
|
"us tons",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
test_units(NonMetric::LongTon, &[
|
|
|
|
|
|
|
|
"long ton",
|
|
|
|
|
|
|
|
"long tons",
|
|
|
|
|
|
|
|
"imperial ton",
|
|
|
|
|
|
|
|
"imperial tons",
|
|
|
|
|
|
|
|
"imp ton",
|
|
|
|
|
|
|
|
"imp tons",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
// Temperature
|
|
|
|
// Temperature
|
|
|
|
assert_eq!(parse_unit("degree Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
test_units(NonMetric::Fahrenheit, &[
|
|
|
|
assert_eq!(parse_unit("degrees Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"degree Fahrenheit",
|
|
|
|
assert_eq!(parse_unit("degree fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"degrees Fahrenheit",
|
|
|
|
assert_eq!(parse_unit("degrees fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"degree fahrenheit",
|
|
|
|
assert_eq!(parse_unit("Fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"degrees fahrenheit",
|
|
|
|
assert_eq!(parse_unit("fahrenheit".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"Fahrenheit",
|
|
|
|
assert_eq!(parse_unit("°F".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"fahrenheit",
|
|
|
|
assert_eq!(parse_unit("F".to_string()), Ok(NonMetric::Fahrenheit));
|
|
|
|
"°F",
|
|
|
|
|
|
|
|
"F",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
// Area
|
|
|
|
// Area
|
|
|
|
assert_eq!(parse_unit("square inch".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
test_units(NonMetric::SquareInch, &[
|
|
|
|
assert_eq!(parse_unit("square inches".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"square inch",
|
|
|
|
assert_eq!(parse_unit("square in".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"square inches",
|
|
|
|
assert_eq!(parse_unit("sq inch".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"square in",
|
|
|
|
assert_eq!(parse_unit("sq inches".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"sq inch",
|
|
|
|
assert_eq!(parse_unit("sq in".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"sq inches",
|
|
|
|
assert_eq!(parse_unit("inch²".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"sq in",
|
|
|
|
assert_eq!(parse_unit("inches²".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"inch²",
|
|
|
|
assert_eq!(parse_unit("in²".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"inches²",
|
|
|
|
assert_eq!(parse_unit("\"²".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"in²",
|
|
|
|
assert_eq!(parse_unit("″²".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"\"²",
|
|
|
|
assert_eq!(parse_unit("inch^2".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"″²",
|
|
|
|
assert_eq!(parse_unit("inches^2".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"inch^2",
|
|
|
|
assert_eq!(parse_unit("in^2".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"inches^2",
|
|
|
|
assert_eq!(parse_unit("\"^2".to_string()), Ok(NonMetric::SquareInch));
|
|
|
|
"in^2",
|
|
|
|
|
|
|
|
"\"^2",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("square foot".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
test_units(NonMetric::SquareFoot, &[
|
|
|
|
assert_eq!(parse_unit("square feet".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"square foot",
|
|
|
|
assert_eq!(parse_unit("square ft".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"square feet",
|
|
|
|
assert_eq!(parse_unit("sq foot".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"square ft",
|
|
|
|
assert_eq!(parse_unit("sq feet".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"sq foot",
|
|
|
|
assert_eq!(parse_unit("sq ft".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"sq feet",
|
|
|
|
assert_eq!(parse_unit("foot²".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"sq ft",
|
|
|
|
assert_eq!(parse_unit("feet²".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"foot²",
|
|
|
|
assert_eq!(parse_unit("ft²".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"feet²",
|
|
|
|
assert_eq!(parse_unit("'²".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"ft²",
|
|
|
|
assert_eq!(parse_unit("′²".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"'²",
|
|
|
|
assert_eq!(parse_unit("foot^2".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"′²",
|
|
|
|
assert_eq!(parse_unit("feet^2".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"foot^2",
|
|
|
|
assert_eq!(parse_unit("ft^2".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"feet^2",
|
|
|
|
assert_eq!(parse_unit("'^2".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"ft^2",
|
|
|
|
assert_eq!(parse_unit("sf".to_string()), Ok(NonMetric::SquareFoot));
|
|
|
|
"'^2",
|
|
|
|
|
|
|
|
"sf",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("acre".to_string()), Ok(NonMetric::Acre));
|
|
|
|
test_units(NonMetric::Acre, &[
|
|
|
|
assert_eq!(parse_unit("acres".to_string()), Ok(NonMetric::Acre));
|
|
|
|
"acre",
|
|
|
|
assert_eq!(parse_unit("ac".to_string()), Ok(NonMetric::Acre));
|
|
|
|
"acres",
|
|
|
|
|
|
|
|
"ac",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("square mile".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
test_units(NonMetric::SquareMile, &[
|
|
|
|
assert_eq!(parse_unit("square miles".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"square mile",
|
|
|
|
assert_eq!(parse_unit("square mi".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"square miles",
|
|
|
|
assert_eq!(parse_unit("sq mile".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"square mi",
|
|
|
|
assert_eq!(parse_unit("sq miles".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"sq mile",
|
|
|
|
assert_eq!(parse_unit("sq mi".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"sq miles",
|
|
|
|
assert_eq!(parse_unit("mile²".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"sq mi",
|
|
|
|
assert_eq!(parse_unit("miles²".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"mile²",
|
|
|
|
assert_eq!(parse_unit("mi²".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"miles²",
|
|
|
|
assert_eq!(parse_unit("mile^2".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"mi²",
|
|
|
|
assert_eq!(parse_unit("miles^2".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"mile^2",
|
|
|
|
assert_eq!(parse_unit("mi^2".to_string()), Ok(NonMetric::SquareMile));
|
|
|
|
"miles^2",
|
|
|
|
|
|
|
|
"mi^2",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
// Volume
|
|
|
|
// Volume
|
|
|
|
assert_eq!(parse_unit("cubic inch".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
test_units(NonMetric::CubicInch, &[
|
|
|
|
assert_eq!(parse_unit("cubic inches".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"cubic inch",
|
|
|
|
assert_eq!(parse_unit("cubic in".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"cubic inches",
|
|
|
|
assert_eq!(parse_unit("cu inch".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"cubic in",
|
|
|
|
assert_eq!(parse_unit("cu inches".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"cu inch",
|
|
|
|
assert_eq!(parse_unit("cu in".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"cu inches",
|
|
|
|
assert_eq!(parse_unit("inch³".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"cu in",
|
|
|
|
assert_eq!(parse_unit("inches³".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"inch³",
|
|
|
|
assert_eq!(parse_unit("in³".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"inches³",
|
|
|
|
assert_eq!(parse_unit("inch^3".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"in³",
|
|
|
|
assert_eq!(parse_unit("inches^3".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"inch^3",
|
|
|
|
assert_eq!(parse_unit("in^3".to_string()), Ok(NonMetric::CubicInch));
|
|
|
|
"inches^3",
|
|
|
|
|
|
|
|
"in^3",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("cubic foot".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
test_units(NonMetric::CubicFoot, &[
|
|
|
|
assert_eq!(parse_unit("cubic feet".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"cubic foot",
|
|
|
|
assert_eq!(parse_unit("cubic ft".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"cubic feet",
|
|
|
|
assert_eq!(parse_unit("cu foot".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"cubic ft",
|
|
|
|
assert_eq!(parse_unit("cu feet".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"cu foot",
|
|
|
|
assert_eq!(parse_unit("cu ft".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"cu feet",
|
|
|
|
assert_eq!(parse_unit("foot³".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"cu ft",
|
|
|
|
assert_eq!(parse_unit("feet³".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"foot³",
|
|
|
|
assert_eq!(parse_unit("ft³".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"feet³",
|
|
|
|
assert_eq!(parse_unit("foot^3".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"ft³",
|
|
|
|
assert_eq!(parse_unit("feet^3".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"foot^3",
|
|
|
|
assert_eq!(parse_unit("ft^3".to_string()), Ok(NonMetric::CubicFoot));
|
|
|
|
"feet^3",
|
|
|
|
|
|
|
|
"ft^3",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
// Fluid volume
|
|
|
|
// Fluid volume
|
|
|
|
assert_eq!(parse_unit("imperial fluid ounce".to_string()), Ok(NonMetric::ImperialFluidOunce));
|
|
|
|
test_units(NonMetric::ImperialFluidOunce, &[
|
|
|
|
assert_eq!(parse_unit("imperial fluid ounces".to_string()), Ok(NonMetric::ImperialFluidOunce));
|
|
|
|
"imperial fluid ounce",
|
|
|
|
assert_eq!(parse_unit("imp fl oz".to_string()), Ok(NonMetric::ImperialFluidOunce));
|
|
|
|
"imperial fluid ounces",
|
|
|
|
assert_eq!(parse_unit("imp fl. oz.".to_string()), Ok(NonMetric::ImperialFluidOunce));
|
|
|
|
"imp fl oz",
|
|
|
|
assert_eq!(parse_unit("imp oz. fl.".to_string()), Ok(NonMetric::ImperialFluidOunce));
|
|
|
|
"imp fl. oz.",
|
|
|
|
|
|
|
|
"imp oz. fl.",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("imperial pint".to_string()), Ok(NonMetric::ImperialPint));
|
|
|
|
test_units(NonMetric::ImperialPint, &[
|
|
|
|
assert_eq!(parse_unit("imperial pints".to_string()), Ok(NonMetric::ImperialPint));
|
|
|
|
"imperial pint",
|
|
|
|
assert_eq!(parse_unit("imp pt".to_string()), Ok(NonMetric::ImperialPint));
|
|
|
|
"imperial pints",
|
|
|
|
assert_eq!(parse_unit("imp p".to_string()), Ok(NonMetric::ImperialPint));
|
|
|
|
"imp pt",
|
|
|
|
|
|
|
|
"imp p",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("imperial quart".to_string()), Ok(NonMetric::ImperialQuart));
|
|
|
|
test_units(NonMetric::ImperialQuart, &[
|
|
|
|
assert_eq!(parse_unit("imperial quarts".to_string()), Ok(NonMetric::ImperialQuart));
|
|
|
|
"imperial quart",
|
|
|
|
assert_eq!(parse_unit("imp qt".to_string()), Ok(NonMetric::ImperialQuart));
|
|
|
|
"imperial quarts",
|
|
|
|
|
|
|
|
"imp qt",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("imperial gallon".to_string()), Ok(NonMetric::ImperialGallon));
|
|
|
|
test_units(NonMetric::ImperialGallon, &[
|
|
|
|
assert_eq!(parse_unit("imperial gallons".to_string()), Ok(NonMetric::ImperialGallon));
|
|
|
|
"imperial gallon",
|
|
|
|
assert_eq!(parse_unit("imp gal".to_string()), Ok(NonMetric::ImperialGallon));
|
|
|
|
"imperial gallons",
|
|
|
|
|
|
|
|
"imp gal",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
test_units(NonMetric::USTeaspoon, &[
|
|
|
|
assert_eq!(parse_unit("US teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"US teaspoon",
|
|
|
|
assert_eq!(parse_unit("US tsp.".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"US teaspoons",
|
|
|
|
assert_eq!(parse_unit("US tsp".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"US tsp.",
|
|
|
|
assert_eq!(parse_unit("us teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"US tsp",
|
|
|
|
assert_eq!(parse_unit("us teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"us teaspoon",
|
|
|
|
assert_eq!(parse_unit("us tsp.".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"us teaspoons",
|
|
|
|
assert_eq!(parse_unit("us tsp".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"us tsp.",
|
|
|
|
assert_eq!(parse_unit("teaspoon".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"us tsp",
|
|
|
|
assert_eq!(parse_unit("teaspoons".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"teaspoon",
|
|
|
|
assert_eq!(parse_unit("tsp.".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"teaspoons",
|
|
|
|
assert_eq!(parse_unit("tsp".to_string()), Ok(NonMetric::USTeaspoon));
|
|
|
|
"tsp.",
|
|
|
|
|
|
|
|
"tsp",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US tablespoon".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
test_units(NonMetric::USTablespoon, &[
|
|
|
|
assert_eq!(parse_unit("US tablespoons".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"US tablespoon",
|
|
|
|
assert_eq!(parse_unit("US Tbsp.".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"US tablespoons",
|
|
|
|
assert_eq!(parse_unit("US Tbsp".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"US Tbsp.",
|
|
|
|
assert_eq!(parse_unit("us tablespoon".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"US Tbsp",
|
|
|
|
assert_eq!(parse_unit("us tablespoons".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"us tablespoon",
|
|
|
|
assert_eq!(parse_unit("us tbsp.".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"us tablespoons",
|
|
|
|
assert_eq!(parse_unit("us tbsp".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"us tbsp.",
|
|
|
|
assert_eq!(parse_unit("tablespoon".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"us tbsp",
|
|
|
|
assert_eq!(parse_unit("tablespoons".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"tablespoon",
|
|
|
|
assert_eq!(parse_unit("Tbsp.".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"tablespoons",
|
|
|
|
assert_eq!(parse_unit("Tbsp".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"Tbsp.",
|
|
|
|
assert_eq!(parse_unit("tbsp.".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"Tbsp",
|
|
|
|
assert_eq!(parse_unit("tbsp".to_string()), Ok(NonMetric::USTablespoon));
|
|
|
|
"tbsp.",
|
|
|
|
|
|
|
|
"tbsp",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US fluid ounce".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
test_units(NonMetric::USFluidOunce, &[
|
|
|
|
assert_eq!(parse_unit("US fluid ounces".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"US fluid ounce",
|
|
|
|
assert_eq!(parse_unit("US fl oz".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"US fluid ounces",
|
|
|
|
assert_eq!(parse_unit("US fl. oz.".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"US fl oz",
|
|
|
|
assert_eq!(parse_unit("US oz. fl.".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"US fl. oz.",
|
|
|
|
assert_eq!(parse_unit("us fluid ounce".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"US oz. fl.",
|
|
|
|
assert_eq!(parse_unit("us fluid ounces".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"us fluid ounce",
|
|
|
|
assert_eq!(parse_unit("us fl oz".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"us fluid ounces",
|
|
|
|
assert_eq!(parse_unit("us fl. oz.".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"us fl oz",
|
|
|
|
assert_eq!(parse_unit("us oz. fl.".to_string()), Ok(NonMetric::USFluidOunce));
|
|
|
|
"us fl. oz.",
|
|
|
|
|
|
|
|
"us oz. fl.",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US cup".to_string()), Ok(NonMetric::USCup));
|
|
|
|
test_units(NonMetric::USCup, &[
|
|
|
|
assert_eq!(parse_unit("US cups".to_string()), Ok(NonMetric::USCup));
|
|
|
|
"US cup",
|
|
|
|
assert_eq!(parse_unit("us cup".to_string()), Ok(NonMetric::USCup));
|
|
|
|
"US cups",
|
|
|
|
assert_eq!(parse_unit("us cups".to_string()), Ok(NonMetric::USCup));
|
|
|
|
"us cup",
|
|
|
|
|
|
|
|
"us cups",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US liquid pint".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
test_units(NonMetric::USLiquidPint, &[
|
|
|
|
assert_eq!(parse_unit("US liquid pints".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"US liquid pint",
|
|
|
|
assert_eq!(parse_unit("US pint".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"US liquid pints",
|
|
|
|
assert_eq!(parse_unit("US pints".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"US pint",
|
|
|
|
assert_eq!(parse_unit("US pt".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"US pints",
|
|
|
|
assert_eq!(parse_unit("US p".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"US pt",
|
|
|
|
assert_eq!(parse_unit("us liquid pint".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"US p",
|
|
|
|
assert_eq!(parse_unit("us liquid pints".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"us liquid pint",
|
|
|
|
assert_eq!(parse_unit("us pint".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"us liquid pints",
|
|
|
|
assert_eq!(parse_unit("us pints".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"us pint",
|
|
|
|
assert_eq!(parse_unit("us pt".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"us pints",
|
|
|
|
assert_eq!(parse_unit("us p".to_string()), Ok(NonMetric::USLiquidPint));
|
|
|
|
"us pt",
|
|
|
|
|
|
|
|
"us p",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US liquid quart".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
test_units(NonMetric::USLiquidQuart, &[
|
|
|
|
assert_eq!(parse_unit("US liquid quarts".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"US liquid quart",
|
|
|
|
assert_eq!(parse_unit("US quart".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"US liquid quarts",
|
|
|
|
assert_eq!(parse_unit("US quarts".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"US quart",
|
|
|
|
assert_eq!(parse_unit("US qt".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"US quarts",
|
|
|
|
assert_eq!(parse_unit("us liquid quart".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"US qt",
|
|
|
|
assert_eq!(parse_unit("us liquid quarts".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"us liquid quart",
|
|
|
|
assert_eq!(parse_unit("us quart".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"us liquid quarts",
|
|
|
|
assert_eq!(parse_unit("us quarts".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"us quart",
|
|
|
|
assert_eq!(parse_unit("us qt".to_string()), Ok(NonMetric::USLiquidQuart));
|
|
|
|
"us quarts",
|
|
|
|
|
|
|
|
"us qt",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(parse_unit("US gallon".to_string()), Ok(NonMetric::USGallon));
|
|
|
|
test_units(NonMetric::USGallon, &[
|
|
|
|
assert_eq!(parse_unit("US gallons".to_string()), Ok(NonMetric::USGallon));
|
|
|
|
"US gallon",
|
|
|
|
assert_eq!(parse_unit("US gal".to_string()), Ok(NonMetric::USGallon));
|
|
|
|
"US gallons",
|
|
|
|
assert_eq!(parse_unit("us gallon".to_string()), Ok(NonMetric::USGallon));
|
|
|
|
"US gal",
|
|
|
|
assert_eq!(parse_unit("us gallons".to_string()), Ok(NonMetric::USGallon));
|
|
|
|
"us gallon",
|
|
|
|
assert_eq!(parse_unit("us gal".to_string()), Ok(NonMetric::USGallon));
|
|
|
|
"us gallons",
|
|
|
|
|
|
|
|
"us gal",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn test_units(unit: NonMetric, spellings: &[&str]) {
|
|
|
|
|
|
|
|
for spelling in spellings {
|
|
|
|
|
|
|
|
assert_eq!(parse_unit(spelling.to_string()), Ok(unit));
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
#[test]
|
|
|
|
fn ambiguous_units() {
|
|
|
|
fn ambiguous_units() {
|
|
|
|
assert_eq!(
|
|
|
|
test_ambiguous_units(NonMetric::ShortTon, NonMetric::LongTon, &[
|
|
|
|
parse_unit("fluid ounce".to_string()),
|
|
|
|
"ton",
|
|
|
|
Err(ParseError::AmbiguousUnit("fluid ounce".to_string(), "imperial", "US"))
|
|
|
|
"tons",
|
|
|
|
);
|
|
|
|
]);
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("fluid ounces".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("fluid ounces".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("fl oz".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("fl oz".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("fl. oz.".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("fl. oz.".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("oz. fl.".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("oz. fl.".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
test_ambiguous_units(NonMetric::ImperialFluidOunce, NonMetric::USFluidOunce, &[
|
|
|
|
parse_unit("pint".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("pint".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("pints".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("pints".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("pt".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("pt".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("p".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("p".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("quart".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("quart".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("quarts".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("quarts".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("qt".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("qt".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("gallon".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("gallon".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("gallons".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("gallons".to_string(), "imperial", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
assert_eq!(
|
|
|
|
|
|
|
|
parse_unit("gal".to_string()),
|
|
|
|
|
|
|
|
Err(ParseError::AmbiguousUnit("gal".to_string(), "imp", "US"))
|
|
|
|
|
|
|
|
);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
|
|
|
|
fn ambiguous_unit_suggestions() {
|
|
|
|
|
|
|
|
let ambiguous_units = [
|
|
|
|
|
|
|
|
"fluid ounce",
|
|
|
|
"fluid ounce",
|
|
|
|
"fluid ounces",
|
|
|
|
"fluid ounces",
|
|
|
|
"fl oz",
|
|
|
|
"fl oz",
|
|
|
|
"fl. oz.",
|
|
|
|
"fl. oz.",
|
|
|
|
"oz. fl.",
|
|
|
|
"oz. fl.",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
test_ambiguous_units(NonMetric::ImperialPint, NonMetric::USLiquidPint, &[
|
|
|
|
"pint",
|
|
|
|
"pint",
|
|
|
|
"pints",
|
|
|
|
"pints",
|
|
|
|
"pt",
|
|
|
|
"pt",
|
|
|
|
"p",
|
|
|
|
"p",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
test_ambiguous_units(NonMetric::ImperialQuart, NonMetric::USLiquidQuart, &[
|
|
|
|
"quart",
|
|
|
|
"quart",
|
|
|
|
"quarts",
|
|
|
|
"quarts",
|
|
|
|
"qt",
|
|
|
|
"qt",
|
|
|
|
|
|
|
|
]);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
test_ambiguous_units(NonMetric::ImperialGallon, NonMetric::USGallon, &[
|
|
|
|
"gallon",
|
|
|
|
"gallon",
|
|
|
|
"gallons",
|
|
|
|
"gallons",
|
|
|
|
"gal",
|
|
|
|
"gal",
|
|
|
|
];
|
|
|
|
]);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for unit in ambiguous_units {
|
|
|
|
fn test_ambiguous_units(unit1: NonMetric, unit2: NonMetric, spellings: &[&str]) {
|
|
|
|
let parsed = parse_unit(unit.to_string());
|
|
|
|
for spelling in spellings {
|
|
|
|
if let Err(ParseError::AmbiguousUnit(unit, prefix1, prefix2)) = parsed {
|
|
|
|
let parsed = parse_unit(spelling.to_string());
|
|
|
|
let suggestion1 = format!("{prefix1} {unit}");
|
|
|
|
if let Err(ParseError::AmbiguousUnit(unit_name, prefix1, prefix2)) = parsed {
|
|
|
|
let suggestion2 = format!("{prefix2} {unit}");
|
|
|
|
assert_eq!(&unit_name, spelling);
|
|
|
|
assert!(parse_unit(suggestion1).is_ok());
|
|
|
|
let suggestion1 = format!("{prefix1} {unit_name}");
|
|
|
|
assert!(parse_unit(suggestion2).is_ok());
|
|
|
|
let suggestion2 = format!("{prefix2} {unit_name}");
|
|
|
|
|
|
|
|
assert_eq!(parse_unit(suggestion1), Ok(unit1));
|
|
|
|
|
|
|
|
assert_eq!(parse_unit(suggestion2), Ok(unit2));
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
unreachable!();
|
|
|
|
panic!("units passed to test_ambiguous_units() must be ambiguous");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|