Weight
P
//! Conversion of weight units.
//!
//! This module provides conversion between various weight units including:
//! - Metric: Gigatonne (Gt), Megatonne (Mt), Metric Ton (t), Kilogram (kg), Gram (g),
//! Milligram (mg), Microgram (μg), Nanogram (ng), Picogram (pg)
//! - Imperial/US: Long Ton, Short Ton, Hundredweight (cwt), Quarter (qtr), Stone (st),
//! Pound (lb), Ounce (oz), Dram (dr), Grain (gr)
//! - Troy: Troy Pound (lb t), Troy Ounce (oz t), Pennyweight (dwt)
//! - Other: Carat (ct), Atomic Mass Unit (amu)
//!
//! # References
//! - [Kilogram](https://en.wikipedia.org/wiki/Kilogram)
//! - [Gram](https://en.wikipedia.org/wiki/Gram)
//! - [Milligram](https://en.wikipedia.org/wiki/Milligram)
//! - [Microgram](https://en.wikipedia.org/wiki/Microgram)
//! - [Nanogram](https://en.wikipedia.org/wiki/Orders_of_magnitude_(mass))
//! - [Picogram](https://en.wikipedia.org/wiki/Orders_of_magnitude_(mass))
//! - [Tonne](https://en.wikipedia.org/wiki/Tonne)
//! - [Gigatonne](https://en.wikipedia.org/wiki/Tonne#Derived_units)
//! - [Megatonne](https://en.wikipedia.org/wiki/Tonne#Derived_units)
//! - [Long Ton](https://en.wikipedia.org/wiki/Long_ton)
//! - [Short Ton](https://en.wikipedia.org/wiki/Short_ton)
//! - [Pound](https://en.wikipedia.org/wiki/Pound_(mass))
//! - [Ounce](https://en.wikipedia.org/wiki/Ounce)
//! - [Stone](https://en.wikipedia.org/wiki/Stone_(unit))
//! - [Quarter](https://en.wikipedia.org/wiki/Quarter_(unit))
//! - [Hundredweight](https://en.wikipedia.org/wiki/Hundredweight)
//! - [Grain](https://en.wikipedia.org/wiki/Grain_(unit))
//! - [Dram](https://en.wikipedia.org/wiki/Dram_(unit))
//! - [Troy Pound](https://en.wikipedia.org/wiki/Troy_weight)
//! - [Troy Ounce](https://en.wikipedia.org/wiki/Troy_weight)
//! - [Pennyweight](https://en.wikipedia.org/wiki/Pennyweight)
//! - [Carat](https://en.wikipedia.org/wiki/Carat_(mass))
//! - [Dalton (Atomic Mass Unit)](https://en.wikipedia.org/wiki/Dalton_(unit))
use std::fmt;
use std::str::FromStr;
/// Trait for types that can be converted into a WeightUnit
pub trait IntoWeightUnit {
fn into_weight_unit(self) -> Result<WeightUnit, String>;
}
impl IntoWeightUnit for WeightUnit {
fn into_weight_unit(self) -> Result<WeightUnit, String> {
Ok(self)
}
}
impl IntoWeightUnit for &str {
fn into_weight_unit(self) -> Result<WeightUnit, String> {
WeightUnit::from_str(self)
}
}
impl IntoWeightUnit for String {
fn into_weight_unit(self) -> Result<WeightUnit, String> {
WeightUnit::from_str(&self)
}
}
/// Supported weight units
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum WeightUnit {
// Large metric units
Gigatonne,
Megatonne,
MetricTon,
// Standard metric units
Kilogram,
Gram,
Milligram,
Microgram,
Nanogram,
Picogram,
// Imperial/US tons and large units
LongTon,
ShortTon,
Hundredweight,
Quarter,
// Imperial/US common units
Stone,
Pound,
Ounce,
Dram,
Grain,
// Troy weight system
TroyPound,
TroyOunce,
Pennyweight,
// Other units
Carat,
AtomicMassUnit,
}
impl fmt::Display for WeightUnit {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = match self {
// Large metric units
Self::Gigatonne => "Gt",
Self::Megatonne => "Mt",
Self::MetricTon => "t",
// Standard metric units
Self::Kilogram => "kg",
Self::Gram => "g",
Self::Milligram => "mg",
Self::Microgram => "μg",
Self::Nanogram => "ng",
Self::Picogram => "pg",
// Imperial/US tons and large units
Self::LongTon => "long ton",
Self::ShortTon => "short ton",
Self::Hundredweight => "cwt",
Self::Quarter => "qtr",
// Imperial/US common units
Self::Stone => "st",
Self::Pound => "lb",
Self::Ounce => "oz",
Self::Dram => "dr",
Self::Grain => "gr",
// Troy weight system
Self::TroyPound => "lb t",
Self::TroyOunce => "oz t",
Self::Pennyweight => "dwt",
// Other units
Self::Carat => "ct",
Self::AtomicMassUnit => "amu",
};
write!(f, "{s}")
}
}
impl WeightUnit {
/// Get the conversion factor to convert this unit to kilograms
fn to_kilogram_factor(self) -> f64 {
match self {
// Large metric units
Self::Gigatonne => 1e12,
Self::Megatonne => 1e9,
Self::MetricTon => 1_000.0,
// Standard metric units (based on 1 kg = 1000 g)
Self::Kilogram => 1.0,
Self::Gram => 1e-3,
Self::Milligram => 1e-6,
Self::Microgram => 1e-9,
Self::Nanogram => 1e-12,
Self::Picogram => 1e-15,
// Imperial/US tons and large units
// Using precise values: 1 lb = 0.45359237 kg exactly (international avoirdupois pound)
Self::LongTon => 1_016.046_908_8, // 2240 lb × 0.45359237 kg/lb
Self::ShortTon => 907.184_74, // 2000 lb × 0.45359237 kg/lb
Self::Hundredweight => 50.802_345_44, // 112 lb × 0.45359237 kg/lb
Self::Quarter => 12.700_586_36, // 28 lb × 0.45359237 kg/lb
// Imperial/US common units (based on 1 lb = 0.45359237 kg exactly)
Self::Stone => 6.350_293_18, // 14 lb × 0.45359237 kg/lb
Self::Pound => 0.453_592_37, // Exactly defined
Self::Ounce => 0.028_349_523_125, // 1/16 lb
Self::Dram => 0.001_771_845_195_312_5, // 1/256 lb
Self::Grain => 0.000_064_798_91, // 1/7000 lb
// Troy weight system (1 troy lb = 0.3732417216 kg exactly)
Self::TroyPound => 0.373_241_721_6, // Exactly defined
Self::TroyOunce => 0.031_103_476_8, // 1/12 troy lb
Self::Pennyweight => 0.001_555_173_84, // 1/240 troy lb
// Other units
Self::Carat => 0.000_2, // Exactly 200 mg
Self::AtomicMassUnit => 1.660_539_066_60e-27, // 2019 CODATA value
}
}
/// Get all supported units as strings
pub fn supported_units() -> Vec<&'static str> {
vec![
"gigatonne",
"megatonne",
"metric-ton",
"kilogram",
"gram",
"milligram",
"microgram",
"nanogram",
"picogram",
"long-ton",
"short-ton",
"hundredweight",
"quarter",
"stone",
"pound",
"ounce",
"dram",
"grain",
"troy-pound",
"troy-ounce",
"pennyweight",
"carat",
"atomic-mass-unit",
]
}
}
impl FromStr for WeightUnit {
type Err = String;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let unit = match s.to_lowercase().as_str() {
// Large metric units
"gigatonne" | "gt" | "gigaton" => Self::Gigatonne,
"megatonne" | "mt" | "megaton" => Self::Megatonne,
"metric-ton" | "metric_ton" | "tonne" | "t" | "ton" => Self::MetricTon,
// Standard metric units
"kilogram" | "kg" | "kilo" => Self::Kilogram,
"gram" | "g" | "gm" => Self::Gram,
"milligram" | "mg" => Self::Milligram,
"microgram" | "μg" | "ug" | "mcg" => Self::Microgram,
"nanogram" | "ng" => Self::Nanogram,
"picogram" | "pg" => Self::Picogram,
// Imperial/US tons and large units
"long-ton" | "long_ton" | "imperial_ton" | "uk_ton" => Self::LongTon,
"short-ton" | "short_ton" | "us_ton" => Self::ShortTon,
"hundredweight" | "cwt" => Self::Hundredweight,
"quarter" | "qtr" => Self::Quarter,
// Imperial/US common units
"stone" | "st" => Self::Stone,
"pound" | "lb" | "lbs" => Self::Pound,
"ounce" | "oz" => Self::Ounce,
"dram" | "drachm" | "dr" => Self::Dram,
"grain" | "gr" => Self::Grain,
// Troy weight system
"troy-pound" | "troy_pound" | "lb_t" | "lbt" => Self::TroyPound,
"troy-ounce" | "troy_ounce" | "oz_t" | "ozt" => Self::TroyOunce,
"pennyweight" | "dwt" | "pwt" => Self::Pennyweight,
// Other units
"carat" | "carrat" | "ct" => Self::Carat,
"atomic-mass-unit" | "atomic_mass_unit" | "amu" | "dalton" | "da" => {
Self::AtomicMassUnit
}
_ => return Err(format!("Unknown weight unit: {s}")),
};
Ok(unit)
}
}
/// Convert weight from one unit to another.
///
/// This function accepts both `WeightUnit` enums and string identifiers.
///
/// # Arguments
///
/// * `value` - The numerical value to convert
/// * `from_unit` - The unit to convert from (can be a `WeightUnit` enum or a string)
/// * `to_unit` - The unit to convert to (can be a `WeightUnit` enum or a string)
///
/// # Returns
///
/// The converted value, or an error if the unit is invalid
///
/// # Examples
///
/// Using enums (type-safe):
/// ```ignore
/// let result = convert_weight(100.0, WeightUnit::Pound, WeightUnit::Kilogram);
/// ```
///
/// Using strings (convenient):
/// ```ignore
/// let result = convert_weight(100.0, "pound", "kilogram");
/// ```
pub fn convert_weight<F, T>(value: f64, from_unit: F, to_unit: T) -> Result<f64, String>
where
F: IntoWeightUnit,
T: IntoWeightUnit,
{
let from = from_unit.into_weight_unit().map_err(|_| {
format!(
"Invalid 'from_unit' value. Supported values are:\n{}",
WeightUnit::supported_units().join(", ")
)
})?;
let to = to_unit.into_weight_unit().map_err(|_| {
format!(
"Invalid 'to_unit' value. Supported values are:\n{}",
WeightUnit::supported_units().join(", ")
)
})?;
// Convert to kilograms first, then to target unit
let kilograms = value * from.to_kilogram_factor();
Ok(kilograms / to.to_kilogram_factor())
}
#[cfg(test)]
mod tests {
use super::*;
const EPSILON: f64 = 1e-6; // Tolerance for floating point comparisons
fn approx_eq(a: f64, b: f64) -> bool {
let diff = (a - b).abs();
// Use relative comparison for large numbers, absolute for small numbers
if a.abs() > 1e10 || b.abs() > 1e10 {
let max = a.abs().max(b.abs());
diff / max < EPSILON
} else {
diff < EPSILON
}
}
#[test]
fn test_kilogram_conversions() {
// Test conversions from kilogram
assert!(approx_eq(
convert_weight(4.0, "kilogram", "kilogram").unwrap(),
4.0
));
assert!(approx_eq(
convert_weight(1.0, "kilogram", "gram").unwrap(),
1_000.0
));
assert!(approx_eq(
convert_weight(4.0, "kilogram", "milligram").unwrap(),
4_000_000.0
));
assert!(approx_eq(
convert_weight(4.0, "kilogram", "metric-ton").unwrap(),
0.004
));
assert!(approx_eq(
convert_weight(3.0, "kilogram", "long-ton").unwrap(),
0.002_952_396_2
));
assert!(approx_eq(
convert_weight(1.0, "kilogram", "short-ton").unwrap(),
0.001_102_311_3
));
assert!(approx_eq(
convert_weight(4.0, "kilogram", "pound").unwrap(),
8.818_490_487
));
assert!(approx_eq(
convert_weight(5.0, "kilogram", "stone").unwrap(),
0.787_365_222
));
assert!(approx_eq(
convert_weight(4.0, "kilogram", "ounce").unwrap(),
141.095_847_8
));
assert!(approx_eq(
convert_weight(3.0, "kilogram", "carat").unwrap(),
15_000.0
));
assert!(approx_eq(
convert_weight(1.0, "kilogram", "atomic-mass-unit").unwrap(),
6.022_140_762e26
));
}
#[test]
fn test_large_metric_conversions() {
// Test gigatonne conversions
assert!(approx_eq(
convert_weight(1.0, "gigatonne", "megatonne").unwrap(),
1_000.0
));
assert!(approx_eq(
convert_weight(1.0, "gigatonne", "metric-ton").unwrap(),
1e9
));
assert!(approx_eq(
convert_weight(1.0, "gigatonne", "kilogram").unwrap(),
1e12
));
assert!(approx_eq(
convert_weight(1.0, "gigatonne", "gram").unwrap(),
1e15
));
// Test megatonne conversions
assert!(approx_eq(
convert_weight(1.0, "megatonne", "metric-ton").unwrap(),
1_000_000.0
));
assert!(approx_eq(
convert_weight(1.0, "megatonne", "kilogram").unwrap(),
1e9
));
assert!(approx_eq(
convert_weight(1.0, "megatonne", "gram").unwrap(),
1e12
));
}
#[test]
fn test_gram_conversions() {
// Test conversions from gram
assert!(approx_eq(
convert_weight(1.0, "gram", "kilogram").unwrap(),
0.001
));
assert!(approx_eq(convert_weight(3.0, "gram", "gram").unwrap(), 3.0));
assert!(approx_eq(
convert_weight(2.0, "gram", "milligram").unwrap(),
2_000.0
));
assert!(approx_eq(
convert_weight(4.0, "gram", "metric-ton").unwrap(),
4e-6
));
assert!(approx_eq(
convert_weight(3.0, "gram", "pound").unwrap(),
0.006_613_867_8
));
}
#[test]
fn test_milligram_conversions() {
// Test conversions from milligram
assert!(approx_eq(
convert_weight(1.0, "milligram", "kilogram").unwrap(),
1e-6
));
assert!(approx_eq(
convert_weight(2.0, "milligram", "gram").unwrap(),
0.002
));
assert!(approx_eq(
convert_weight(3.0, "milligram", "milligram").unwrap(),
3.0
));
assert!(approx_eq(
convert_weight(1.0, "milligram", "carat").unwrap(),
0.005
));
}
#[test]
fn test_small_metric_conversions() {
// Test microgram conversions (1 μg = 0.000001 g)
assert!(approx_eq(
convert_weight(1.0, "microgram", "gram").unwrap(),
1e-6
));
assert!(approx_eq(
convert_weight(1_000.0, "microgram", "milligram").unwrap(),
1.0
));
assert!(approx_eq(
convert_weight(1.0, "microgram", "kilogram").unwrap(),
1e-9
));
// Test nanogram conversions (1 ng = 0.000000001 g)
assert!(approx_eq(
convert_weight(1.0, "nanogram", "gram").unwrap(),
1e-9
));
assert!(approx_eq(
convert_weight(1_000.0, "nanogram", "microgram").unwrap(),
1.0
));
assert!(approx_eq(
convert_weight(1.0, "nanogram", "kilogram").unwrap(),
1e-12
));
// Test picogram conversions (1 pg = 0.000000000001 g)
assert!(approx_eq(
convert_weight(1.0, "picogram", "gram").unwrap(),
1e-12
));
assert!(approx_eq(
convert_weight(1_000.0, "picogram", "nanogram").unwrap(),
1.0
));
assert!(approx_eq(
convert_weight(1.0, "picogram", "kilogram").unwrap(),
1e-15
));
}
#[test]
fn test_metric_ton_conversions() {
// Test conversions from metric ton
assert!(approx_eq(
convert_weight(2.0, "metric-ton", "kilogram").unwrap(),
2_000.0
));
assert!(approx_eq(
convert_weight(2.0, "metric-ton", "gram").unwrap(),
2_000_000.0
));
assert!(approx_eq(
convert_weight(3.0, "metric-ton", "milligram").unwrap(),
3_000_000_000.0
));
assert!(approx_eq(
convert_weight(2.0, "metric-ton", "metric-ton").unwrap(),
2.0
));
assert!(approx_eq(
convert_weight(3.0, "metric-ton", "pound").unwrap(),
6_613.867_865
));
}
#[test]
fn test_long_ton_conversions() {
// Test conversions from long ton (UK ton = 1016.0469088 kg precisely)
assert!(approx_eq(
convert_weight(4.0, "long-ton", "kilogram").unwrap(),
4_064.187_635_2
));
assert!(approx_eq(
convert_weight(4.0, "long-ton", "gram").unwrap(),
4_064_187.635_2
));
assert!(approx_eq(
convert_weight(4.0, "long-ton", "metric-ton").unwrap(),
4.064_187_635_2
));
assert!(approx_eq(
convert_weight(3.0, "long-ton", "long-ton").unwrap(),
3.0
));
assert!(approx_eq(
convert_weight(1.0, "long-ton", "short-ton").unwrap(),
1.12
));
}
#[test]
fn test_imperial_large_units() {
// Test hundredweight (112 lb = 50.80234544 kg precisely)
assert!(approx_eq(
convert_weight(1.0, "hundredweight", "kilogram").unwrap(),
50.802_345_44
));
assert!(approx_eq(
convert_weight(1.0, "hundredweight", "gram").unwrap(),
50_802.345_44
));
assert!(approx_eq(
convert_weight(1.0, "hundredweight", "pound").unwrap(),
112.0
));
assert!(approx_eq(
convert_weight(20.0, "hundredweight", "long-ton").unwrap(),
1.0
));
// Test quarter (28 lb = 12.70058636 kg precisely)
assert!(approx_eq(
convert_weight(1.0, "quarter", "kilogram").unwrap(),
12.700_586_36
));
assert!(approx_eq(
convert_weight(1.0, "quarter", "gram").unwrap(),
12_700.586_36
));
assert!(approx_eq(
convert_weight(1.0, "quarter", "pound").unwrap(),
28.0
));
assert!(approx_eq(
convert_weight(4.0, "quarter", "hundredweight").unwrap(),
1.0
));
}
#[test]
fn test_short_ton_conversions() {
// Test conversions from short ton (2000 lb = 907.18474 kg precisely)
assert!(approx_eq(
convert_weight(3.0, "short-ton", "kilogram").unwrap(),
2_721.554_22
));
assert!(approx_eq(
convert_weight(3.0, "short-ton", "gram").unwrap(),
2_721_554.22
));
assert!(approx_eq(
convert_weight(1.0, "short-ton", "milligram").unwrap(),
907_184_740.0
));
assert!(approx_eq(
convert_weight(4.0, "short-ton", "metric-ton").unwrap(),
3.628_738_96
));
assert!(approx_eq(
convert_weight(2.0, "short-ton", "pound").unwrap(),
4_000.0
));
}
#[test]
fn test_pound_conversions() {
// Test conversions from pound (0.45359237 kg exactly)
assert!(approx_eq(
convert_weight(4.0, "pound", "kilogram").unwrap(),
1.814_369_48
));
assert!(approx_eq(
convert_weight(2.0, "pound", "gram").unwrap(),
907.184_74
));
assert!(approx_eq(
convert_weight(3.0, "pound", "milligram").unwrap(),
1_360_777.11
));
assert!(approx_eq(
convert_weight(3.0, "pound", "pound").unwrap(),
3.0
));
assert!(approx_eq(
convert_weight(1.0, "pound", "ounce").unwrap(),
16.0
));
assert!(approx_eq(
convert_weight(1.0, "pound", "carat").unwrap(),
2_267.961_85
));
}
#[test]
fn test_stone_conversions() {
// Test conversions from stone (14 lb = 6.35029318 kg precisely)
assert!(approx_eq(
convert_weight(5.0, "stone", "kilogram").unwrap(),
31.751_465_9
));
assert!(approx_eq(
convert_weight(2.0, "stone", "gram").unwrap(),
12_700.586_36
));
assert!(approx_eq(
convert_weight(2.0, "stone", "pound").unwrap(),
28.0
));
assert!(approx_eq(
convert_weight(1.0, "stone", "ounce").unwrap(),
224.0
));
}
#[test]
fn test_ounce_conversions() {
// Test conversions from ounce (1/16 lb = 0.028349523125 kg precisely)
assert!(approx_eq(
convert_weight(3.0, "ounce", "kilogram").unwrap(),
0.085_048_569_375
));
assert!(approx_eq(
convert_weight(3.0, "ounce", "gram").unwrap(),
85.048_569_375
));
assert!(approx_eq(
convert_weight(1.0, "ounce", "pound").unwrap(),
0.0625
));
assert!(approx_eq(
convert_weight(2.0, "ounce", "ounce").unwrap(),
2.0
));
assert!(approx_eq(
convert_weight(1.0, "ounce", "carat").unwrap(),
141.747_615_625
));
}
#[test]
fn test_small_imperial_units() {
// Test dram (1/256 lb = 0.0017718451953125 kg precisely)
assert!(approx_eq(
convert_weight(1.0, "dram", "gram").unwrap(),
1.771_845_195_312_5
));
assert!(approx_eq(
convert_weight(1.0, "dram", "kilogram").unwrap(),
0.001_771_845_195_312_5
));
assert!(approx_eq(
convert_weight(256.0, "dram", "pound").unwrap(),
1.0
));
assert!(approx_eq(
convert_weight(16.0, "dram", "ounce").unwrap(),
1.0
));
// Test grain (1/7000 lb = 0.00006479891 kg precisely)
assert!(approx_eq(
convert_weight(1.0, "grain", "gram").unwrap(),
0.064_798_91
));
assert!(approx_eq(
convert_weight(1.0, "grain", "kilogram").unwrap(),
0.000_064_798_91
));
assert!(approx_eq(
convert_weight(7000.0, "grain", "pound").unwrap(),
1.0
));
}
#[test]
fn test_carat_conversions() {
// Test conversions from carat
assert!(approx_eq(
convert_weight(1.0, "carat", "kilogram").unwrap(),
0.000_2
));
assert!(approx_eq(
convert_weight(4.0, "carat", "gram").unwrap(),
0.8
));
assert!(approx_eq(
convert_weight(2.0, "carat", "milligram").unwrap(),
400.0
));
assert!(approx_eq(
convert_weight(4.0, "carat", "carat").unwrap(),
4.0
));
}
#[test]
fn test_troy_weight_system() {
// Test troy pound (0.3732417216 kg exactly)
assert!(approx_eq(
convert_weight(1.0, "troy-pound", "gram").unwrap(),
373.241_721_6
));
assert!(approx_eq(
convert_weight(1.0, "troy-pound", "kilogram").unwrap(),
0.373_241_721_6
));
assert!(approx_eq(
convert_weight(1.0, "troy-pound", "pound").unwrap(),
0.822_857_143
));
assert!(approx_eq(
convert_weight(1.0, "troy-pound", "troy-ounce").unwrap(),
12.0
));
// Test troy ounce (1/12 troy lb = 0.0311034768 kg exactly)
assert!(approx_eq(
convert_weight(1.0, "troy-ounce", "gram").unwrap(),
31.103_476_8
));
assert!(approx_eq(
convert_weight(1.0, "troy-ounce", "kilogram").unwrap(),
0.031_103_476_8
));
assert!(approx_eq(
convert_weight(1.0, "troy-ounce", "ounce").unwrap(),
1.097_142_857
));
assert!(approx_eq(
convert_weight(12.0, "troy-ounce", "troy-pound").unwrap(),
1.0
));
assert!(approx_eq(
convert_weight(1.0, "troy-ounce", "pennyweight").unwrap(),
20.0
));
// Test pennyweight (1/240 troy lb = 0.00155517384 kg exactly)
assert!(approx_eq(
convert_weight(1.0, "pennyweight", "gram").unwrap(),
1.555_173_84
));
assert!(approx_eq(
convert_weight(1.0, "pennyweight", "kilogram").unwrap(),
0.001_555_173_84
));
assert!(approx_eq(
convert_weight(20.0, "pennyweight", "troy-ounce").unwrap(),
1.0
));
assert!(approx_eq(
convert_weight(240.0, "pennyweight", "troy-pound").unwrap(),
1.0
));
}
#[test]
fn test_atomic_mass_unit_conversions() {
// Test conversions from atomic mass unit
assert!(approx_eq(
convert_weight(4.0, "atomic-mass-unit", "kilogram").unwrap(),
6.642_160_796e-27
));
assert!(approx_eq(
convert_weight(2.0, "atomic-mass-unit", "atomic-mass-unit").unwrap(),
2.0
));
}
#[test]
fn test_using_enums() {
// Test using enums (type-safe)
assert!(approx_eq(
convert_weight(1.0, WeightUnit::Kilogram, WeightUnit::Gram).unwrap(),
1_000.0
));
assert!(approx_eq(
convert_weight(100.0, WeightUnit::Pound, WeightUnit::Kilogram).unwrap(),
45.359_237
));
}
#[test]
fn test_mixed_usage() {
// Test mixed usage (enum and string)
assert!(approx_eq(
convert_weight(1.0, WeightUnit::Kilogram, "pound").unwrap(),
2.204_622_622
));
assert!(approx_eq(
convert_weight(16.0, "ounce", WeightUnit::Pound).unwrap(),
1.0
));
}
#[test]
fn test_invalid_units() {
// Test invalid units
assert!(convert_weight(4.0, "slug", "kilogram").is_err());
assert!(convert_weight(4.0, "kilogram", "wrongUnit").is_err());
}
#[test]
fn test_roundtrip_conversion() {
// Test roundtrip conversion
let original = 100.0;
let converted = convert_weight(original, "pound", "kilogram").unwrap();
let back = convert_weight(converted, "kilogram", "pound").unwrap();
assert!(approx_eq(original, back));
}
#[test]
fn test_string_ownership() {
// Test String (owned) conversion
let unit_string = String::from("kilogram");
assert_eq!(
unit_string.into_weight_unit().unwrap(),
WeightUnit::Kilogram
);
let invalid_string = String::from("invalid");
assert!(invalid_string.into_weight_unit().is_err());
}
#[test]
fn test_display_implementation() {
// Test Display implementation for all units
assert_eq!(format!("{}", WeightUnit::Gigatonne), "Gt");
assert_eq!(format!("{}", WeightUnit::Megatonne), "Mt");
assert_eq!(format!("{}", WeightUnit::MetricTon), "t");
assert_eq!(format!("{}", WeightUnit::Kilogram), "kg");
assert_eq!(format!("{}", WeightUnit::Gram), "g");
assert_eq!(format!("{}", WeightUnit::Milligram), "mg");
assert_eq!(format!("{}", WeightUnit::Microgram), "μg");
assert_eq!(format!("{}", WeightUnit::Nanogram), "ng");
assert_eq!(format!("{}", WeightUnit::Picogram), "pg");
assert_eq!(format!("{}", WeightUnit::LongTon), "long ton");
assert_eq!(format!("{}", WeightUnit::ShortTon), "short ton");
assert_eq!(format!("{}", WeightUnit::Hundredweight), "cwt");
assert_eq!(format!("{}", WeightUnit::Quarter), "qtr");
assert_eq!(format!("{}", WeightUnit::Stone), "st");
assert_eq!(format!("{}", WeightUnit::Pound), "lb");
assert_eq!(format!("{}", WeightUnit::Ounce), "oz");
assert_eq!(format!("{}", WeightUnit::Dram), "dr");
assert_eq!(format!("{}", WeightUnit::Grain), "gr");
assert_eq!(format!("{}", WeightUnit::TroyPound), "lb t");
assert_eq!(format!("{}", WeightUnit::TroyOunce), "oz t");
assert_eq!(format!("{}", WeightUnit::Pennyweight), "dwt");
assert_eq!(format!("{}", WeightUnit::Carat), "ct");
assert_eq!(format!("{}", WeightUnit::AtomicMassUnit), "amu");
}
#[test]
fn test_alternative_names() {
// Test alternative unit names
assert!(convert_weight(1.0, "kg", "gram").is_ok());
assert!(convert_weight(1.0, "lb", "kilogram").is_ok());
assert!(convert_weight(1.0, "oz", "gram").is_ok());
assert!(convert_weight(1.0, "tonne", "kilogram").is_ok());
assert!(convert_weight(1.0, "dalton", "kilogram").is_ok());
assert!(convert_weight(1.0, "gt", "megatonne").is_ok());
assert!(convert_weight(1.0, "mt", "metric-ton").is_ok());
assert!(convert_weight(1.0, "ug", "gram").is_ok());
assert!(convert_weight(1.0, "μg", "microgram").is_ok());
assert!(convert_weight(1.0, "cwt", "kilogram").is_ok());
assert!(convert_weight(1.0, "qtr", "quarter").is_ok());
assert!(convert_weight(1.0, "dr", "gram").is_ok());
assert!(convert_weight(1.0, "gr", "grain").is_ok());
assert!(convert_weight(1.0, "ozt", "gram").is_ok());
assert!(convert_weight(1.0, "lbt", "troy-pound").is_ok());
assert!(convert_weight(1.0, "dwt", "gram").is_ok());
}
}
