From 07daf8f3d8c0a0955003b29ce648562fb8b58f3c Mon Sep 17 00:00:00 2001 From: Mark Timmings Date: Fri, 16 Dec 2022 16:02:05 +0000 Subject: [PATCH] Added cubic metres, cubic feet, cubic inches and oil barrels --- Cargo.toml | 2 +- README.md | 4 + src/volume.rs | 852 +++++++ tests/data_storage.rs | 2 +- tests/data_transfer_rate.rs | 2 +- tests/volume.rs | 4310 +++++++++++++++++++++++++++++------ 6 files changed, 4484 insertions(+), 688 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 39bfd92..aa314b2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "unit-conversions" -version = "0.1.12" +version = "0.1.13" edition = "2018" authors = ["Mark Timmings "] license = "MIT" diff --git a/README.md b/README.md index f119dd8..0aacef9 100644 --- a/README.md +++ b/README.md @@ -192,11 +192,15 @@ Each unit of measure then includes functions to convert to each for example, con ### Volume + * Cubic Feet (feet3) + * Cubic Inches (inch3) + * Cubic Metres (m3) * Fluid Ounces (floz) * Gallons (gal) * Kilolitres (kl) * Litres (l) * Millilitres (ml) + * Oil Barrels (oilbarrel) * Pints (pt) * Quarts (qt) * Tablespoons (tbsp) diff --git a/src/volume.rs b/src/volume.rs index aef975d..1cdadff 100644 --- a/src/volume.rs +++ b/src/volume.rs @@ -6,6 +6,357 @@ //! # Volume based converters +/// Cubic Feet conversion functions +pub mod cubic_feet { + /// Converts the supplied Cubic Feet value to Millilitres + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_millilitres(value: f64) -> f64 { + return value * 28316.8; + } + /// Converts the supplied Cubic Feet value to Litres + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_litres(value: f64) -> f64 { + return value * 28.3168; + } + /// Converts the supplied Cubic Feet value to Kilolitres + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_kilolitres(value: f64) -> f64 { + return value / 35.3147; + } + /// Converts the supplied Cubic Feet value to Teaspoons + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_teaspoons(value: f64) -> f64 { + return value * 4783.74; + } + /// Converts the supplied Cubic Feet value to Tablespoons + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_tablespoons(value: f64) -> f64 { + return value * 1594.58; + } + /// Converts the supplied Cubic Feet value to Quarts + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_quarts(value: f64) -> f64 { + return value * 24.9153; + } + /// Converts the supplied Cubic Feet value to Pints + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_pints(value: f64) -> f64 { + return value * 49.8307; + } + /// Converts the supplied Cubic Feet value to Gallons + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_gallons(value: f64) -> f64 { + return value * 6.22884; + } + /// Converts the supplied Cubic Feet value to Fluid Ounces + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_fluid_ounces(value: f64) -> f64 { + return value * 996.614; + } + /// Converts the supplied Cubic Feet value to US Teaspoons + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_teaspoons(value: f64) -> f64 { + return value * 5745.04; + } + /// Converts the supplied Cubic Feet value to US Tablespoons + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_tablespoons(value: f64) -> f64 { + return value * 1915.01; + } + /// Converts the supplied Cubic Feet value to US Quarts + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_quarts(value: f64) -> f64 { + return value * 29.9221; + } + /// Converts the supplied Cubic Feet value to US Pints + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_pints(value: f64) -> f64 { + return value * 59.8442; + } + /// Converts the supplied Cubic Feet value to US Gallons + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_gallons(value: f64) -> f64 { + return value * 7.48052; + } + /// Converts the supplied Cubic Feet value to US Fluid Ounces + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_fluid_ounces(value: f64) -> f64 { + return value * 957.506; + } + /// Converts the supplied Cubic Feet value to US Cups + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_u_s_cups(value: f64) -> f64 { + return value * 117.987; + } + /// Converts the supplied Cubic Feet value to Cubic Metres + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 35.3147; + } + /// Converts the supplied Cubic Feet value to Cubic Inches + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 1728.0; + } + /// Converts the supplied Cubic Feet value to Oil Barrels + /// # Arguments + /// * `value` - The Cubic Feet input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 5.61458; + } +} +/// Cubic Inches conversion functions +pub mod cubic_inches { + /// Converts the supplied Cubic Inches value to Millilitres + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_millilitres(value: f64) -> f64 { + return value * 16.3871; + } + /// Converts the supplied Cubic Inches value to Litres + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_litres(value: f64) -> f64 { + return value / 61.0237; + } + /// Converts the supplied Cubic Inches value to Kilolitres + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_kilolitres(value: f64) -> f64 { + return value / 61023.7; + } + /// Converts the supplied Cubic Inches value to Teaspoons + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_teaspoons(value: f64) -> f64 { + return value * 2.76837; + } + /// Converts the supplied Cubic Inches value to Tablespoons + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_tablespoons(value: f64) -> f64 { + return value / 1.08367; + } + /// Converts the supplied Cubic Inches value to Quarts + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_quarts(value: f64) -> f64 { + return value / 69.3549; + } + /// Converts the supplied Cubic Inches value to Pints + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_pints(value: f64) -> f64 { + return value / 34.6774; + } + /// Converts the supplied Cubic Inches value to Gallons + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_gallons(value: f64) -> f64 { + return value / 277.419; + } + /// Converts the supplied Cubic Inches value to Fluid Ounces + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_fluid_ounces(value: f64) -> f64 { + return value / 1.73387; + } + /// Converts the supplied Cubic Inches value to US Teaspoons + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_teaspoons(value: f64) -> f64 { + return value * 3.32468; + } + /// Converts the supplied Cubic Inches value to US Tablespoons + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_tablespoons(value: f64) -> f64 { + return value * 1.10823; + } + /// Converts the supplied Cubic Inches value to US Quarts + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_quarts(value: f64) -> f64 { + return value / 57.75; + } + /// Converts the supplied Cubic Inches value to US Pints + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_pints(value: f64) -> f64 { + return value / 28.875; + } + /// Converts the supplied Cubic Inches value to US Gallons + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_gallons(value: f64) -> f64 { + return value / 231.0; + } + /// Converts the supplied Cubic Inches value to US Fluid Ounces + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_fluid_ounces(value: f64) -> f64 { + return value / 1.80469; + } + /// Converts the supplied Cubic Inches value to US Cups + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_u_s_cups(value: f64) -> f64 { + return value / 14.6457; + } + /// Converts the supplied Cubic Inches value to Cubic Metres + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 61023.7; + } + /// Converts the supplied Cubic Inches value to Cubic Feet + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 1728.0; + } + /// Converts the supplied Cubic Inches value to Oil Barrels + /// # Arguments + /// * `value` - The Cubic Inches input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 9702.0; + } +} +/// Cubic Metres conversion functions +pub mod cubic_metres { + /// Converts the supplied Cubic Metres value to Millilitres + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_millilitres(value: f64) -> f64 { + return value * 1000000.0; + } + /// Converts the supplied Cubic Metres value to Litres + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_litres(value: f64) -> f64 { + return value * 1000.0; + } + /// Converts the supplied Cubic Metres value to Kilolitres + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_kilolitres(value: f64) -> f64 { + return value * 1.0; + } + /// Converts the supplied Cubic Metres value to Teaspoons + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_teaspoons(value: f64) -> f64 { + return value * 168936.0; + } + /// Converts the supplied Cubic Metres value to Tablespoons + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_tablespoons(value: f64) -> f64 { + return value * 56312.1; + } + /// Converts the supplied Cubic Metres value to Quarts + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_quarts(value: f64) -> f64 { + return value * 879.877; + } + /// Converts the supplied Cubic Metres value to Pints + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_pints(value: f64) -> f64 { + return value * 1759.75; + } + /// Converts the supplied Cubic Metres value to Gallons + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_gallons(value: f64) -> f64 { + return value * 219.969; + } + /// Converts the supplied Cubic Metres value to Fluid Ounces + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_fluid_ounces(value: f64) -> f64 { + return value * 35195.1; + } + /// Converts the supplied Cubic Metres value to US Teaspoons + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_teaspoons(value: f64) -> f64 { + return value * 202884.0; + } + /// Converts the supplied Cubic Metres value to US Tablespoons + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_tablespoons(value: f64) -> f64 { + return value * 67628.0; + } + /// Converts the supplied Cubic Metres value to US Quarts + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_quarts(value: f64) -> f64 { + return value * 1056.69; + } + /// Converts the supplied Cubic Metres value to US Pints + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_pints(value: f64) -> f64 { + return value * 2113.38; + } + /// Converts the supplied Cubic Metres value to US Gallons + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_gallons(value: f64) -> f64 { + return value * 264.172; + } + /// Converts the supplied Cubic Metres value to US Fluid Ounces + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_fluid_ounces(value: f64) -> f64 { + return value * 33814.0; + } + /// Converts the supplied Cubic Metres value to US Cups + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_u_s_cups(value: f64) -> f64 { + return value * 4166.67; + } + /// Converts the supplied Cubic Metres value to Cubic Feet + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value * 35.3147; + } + /// Converts the supplied Cubic Metres value to Cubic Inches + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 61023.7; + } + /// Converts the supplied Cubic Metres value to Oil Barrels + /// # Arguments + /// * `value` - The Cubic Metres input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value * 6.28981; + } +} /// Fluid Ounces conversion functions pub mod fluid_ounces { /// Converts the supplied Fluid Ounces value to Millilitres @@ -98,6 +449,30 @@ pub mod fluid_ounces { pub fn to_u_s_cups(value: f64) -> f64 { return value / 8.3267384046639071232; } + /// Converts the supplied Fluid Ounces value to Cubic Metres + /// # Arguments + /// * `value` - The Fluid Ounces input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 35195.1; + } + /// Converts the supplied Fluid Ounces value to Cubic Feet + /// # Arguments + /// * `value` - The Fluid Ounces input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 996.614; + } + /// Converts the supplied Fluid Ounces value to Cubic Inches + /// # Arguments + /// * `value` - The Fluid Ounces input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 1.73387; + } + /// Converts the supplied Fluid Ounces value to Oil Barrels + /// # Arguments + /// * `value` - The Fluid Ounces input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 5595.57; + } } /// Gallons conversion functions pub mod gallons { @@ -191,6 +566,30 @@ pub mod gallons { pub fn to_u_s_cups(value: f64) -> f64 { return value / 0.052042115029149417472; } + /// Converts the supplied Gallons value to Cubic Metres + /// # Arguments + /// * `value` - The Gallons input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 219.969; + } + /// Converts the supplied Gallons value to Cubic Feet + /// # Arguments + /// * `value` - The Gallons input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 6.22884; + } + /// Converts the supplied Gallons value to Cubic Inches + /// # Arguments + /// * `value` - The Gallons input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 277.419; + } + /// Converts the supplied Gallons value to Oil Barrels + /// # Arguments + /// * `value` - The Gallons input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 34.9723; + } } /// Kilolitres conversion functions pub mod kilolitres { @@ -284,6 +683,30 @@ pub mod kilolitres { pub fn to_u_s_cups(value: f64) -> f64 { return value / 0.000236588236499999989; } + /// Converts the supplied Kilolitres value to Cubic Metres + /// # Arguments + /// * `value` - The Kilolitres input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value * 1.0; + } + /// Converts the supplied Kilolitres value to Cubic Feet + /// # Arguments + /// * `value` - The Kilolitres input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value * 35.3147; + } + /// Converts the supplied Kilolitres value to Cubic Inches + /// # Arguments + /// * `value` - The Kilolitres input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 61023.7; + } + /// Converts the supplied Kilolitres value to Oil Barrels + /// # Arguments + /// * `value` - The Kilolitres input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value * 6.28981; + } } /// Litres conversion functions pub mod litres { @@ -377,6 +800,30 @@ pub mod litres { pub fn to_u_s_cups(value: f64) -> f64 { return value / 0.23658823649999998976; } + /// Converts the supplied Litres value to Cubic Metres + /// # Arguments + /// * `value` - The Litres input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 1000.0; + } + /// Converts the supplied Litres value to Cubic Feet + /// # Arguments + /// * `value` - The Litres input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 28.3168; + } + /// Converts the supplied Litres value to Cubic Inches + /// # Arguments + /// * `value` - The Litres input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 61.0237; + } + /// Converts the supplied Litres value to Oil Barrels + /// # Arguments + /// * `value` - The Litres input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 158.987; + } } /// Millilitres conversion functions pub mod millilitres { @@ -470,6 +917,147 @@ pub mod millilitres { pub fn to_u_s_cups(value: f64) -> f64 { return value / 236.58823649999998976; } + /// Converts the supplied Millilitres value to Cubic Metres + /// # Arguments + /// * `value` - The Millilitres input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 1000000.0; + } + /// Converts the supplied Millilitres value to Cubic Feet + /// # Arguments + /// * `value` - The Millilitres input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 28316.8; + } + /// Converts the supplied Millilitres value to Cubic Inches + /// # Arguments + /// * `value` - The Millilitres input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value / 16.3871; + } + /// Converts the supplied Millilitres value to Oil Barrels + /// # Arguments + /// * `value` - The Millilitres input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 158987.0; + } +} +/// Oil Barrels conversion functions +pub mod oil_barrels { + /// Converts the supplied Oil Barrels value to Millilitres + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_millilitres(value: f64) -> f64 { + return value * 158987.0; + } + /// Converts the supplied Oil Barrels value to Litres + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_litres(value: f64) -> f64 { + return value * 158.987; + } + /// Converts the supplied Oil Barrels value to Kilolitres + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_kilolitres(value: f64) -> f64 { + return value / 6.28981; + } + /// Converts the supplied Oil Barrels value to Teaspoons + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_teaspoons(value: f64) -> f64 { + return value * 26858.7; + } + /// Converts the supplied Oil Barrels value to Tablespoons + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_tablespoons(value: f64) -> f64 { + return value * 8952.91; + } + /// Converts the supplied Oil Barrels value to Quarts + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_quarts(value: f64) -> f64 { + return value * 139.889; + } + /// Converts the supplied Oil Barrels value to Pints + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_pints(value: f64) -> f64 { + return value * 279.779; + } + /// Converts the supplied Oil Barrels value to Gallons + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_gallons(value: f64) -> f64 { + return value * 34.9723; + } + /// Converts the supplied Oil Barrels value to Fluid Ounces + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_fluid_ounces(value: f64) -> f64 { + return value * 5595.57; + } + /// Converts the supplied Oil Barrels value to US Teaspoons + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_teaspoons(value: f64) -> f64 { + return value * 32256.0; + } + /// Converts the supplied Oil Barrels value to US Tablespoons + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_tablespoons(value: f64) -> f64 { + return value * 10752.0; + } + /// Converts the supplied Oil Barrels value to US Quarts + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_quarts(value: f64) -> f64 { + return value * 168.0; + } + /// Converts the supplied Oil Barrels value to US Pints + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_pints(value: f64) -> f64 { + return value * 336.0; + } + /// Converts the supplied Oil Barrels value to US Gallons + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_gallons(value: f64) -> f64 { + return value * 42.0; + } + /// Converts the supplied Oil Barrels value to US Fluid Ounces + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_fluid_ounces(value: f64) -> f64 { + return value * 5376.0; + } + /// Converts the supplied Oil Barrels value to US Cups + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_u_s_cups(value: f64) -> f64 { + return value * 662.447; + } + /// Converts the supplied Oil Barrels value to Cubic Metres + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 6.28981; + } + /// Converts the supplied Oil Barrels value to Cubic Feet + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value * 5.61458; + } + /// Converts the supplied Oil Barrels value to Cubic Inches + /// # Arguments + /// * `value` - The Oil Barrels input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 9702.0; + } } /// Pints conversion functions pub mod pints { @@ -563,6 +1151,30 @@ pub mod pints { pub fn to_u_s_cups(value: f64) -> f64 { return value / 0.41633692023319535616; } + /// Converts the supplied Pints value to Cubic Metres + /// # Arguments + /// * `value` - The Pints input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 1759.75; + } + /// Converts the supplied Pints value to Cubic Feet + /// # Arguments + /// * `value` - The Pints input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 49.8307; + } + /// Converts the supplied Pints value to Cubic Inches + /// # Arguments + /// * `value` - The Pints input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 34.6774; + } + /// Converts the supplied Pints value to Oil Barrels + /// # Arguments + /// * `value` - The Pints input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 279.779; + } } /// Quarts conversion functions pub mod quarts { @@ -656,6 +1268,30 @@ pub mod quarts { pub fn to_u_s_cups(value: f64) -> f64 { return value / 0.20816846011659767808; } + /// Converts the supplied Quarts value to Cubic Metres + /// # Arguments + /// * `value` - The Quarts input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 879.877; + } + /// Converts the supplied Quarts value to Cubic Feet + /// # Arguments + /// * `value` - The Quarts input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 24.9153; + } + /// Converts the supplied Quarts value to Cubic Inches + /// # Arguments + /// * `value` - The Quarts input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 69.3549; + } + /// Converts the supplied Quarts value to Oil Barrels + /// # Arguments + /// * `value` - The Quarts input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 139.889; + } } /// Tablespoons conversion functions pub mod tablespoons { @@ -749,6 +1385,30 @@ pub mod tablespoons { pub fn to_u_s_cups(value: f64) -> f64 { return value / 13.322781447462250496; } + /// Converts the supplied Tablespoons value to Cubic Metres + /// # Arguments + /// * `value` - The Tablespoons input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 56312.1; + } + /// Converts the supplied Tablespoons value to Cubic Feet + /// # Arguments + /// * `value` - The Tablespoons input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 1594.58; + } + /// Converts the supplied Tablespoons value to Cubic Inches + /// # Arguments + /// * `value` - The Tablespoons input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 1.08367; + } + /// Converts the supplied Tablespoons value to Oil Barrels + /// # Arguments + /// * `value` - The Tablespoons input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 8952.91; + } } /// Teaspoons conversion functions pub mod teaspoons { @@ -842,6 +1502,30 @@ pub mod teaspoons { pub fn to_u_s_cups(value: f64) -> f64 { return value / 39.968344342386753536; } + /// Converts the supplied Teaspoons value to Cubic Metres + /// # Arguments + /// * `value` - The Teaspoons input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 168936.0; + } + /// Converts the supplied Teaspoons value to Cubic Feet + /// # Arguments + /// * `value` - The Teaspoons input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 4783.74; + } + /// Converts the supplied Teaspoons value to Cubic Inches + /// # Arguments + /// * `value` - The Teaspoons input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value / 2.76837; + } + /// Converts the supplied Teaspoons value to Oil Barrels + /// # Arguments + /// * `value` - The Teaspoons input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 26858.7; + } } /// US Cups conversion functions pub mod u_s_cups { @@ -935,6 +1619,30 @@ pub mod u_s_cups { pub fn to_u_s_fluid_ounces(value: f64) -> f64 { return value * 8.0; } + /// Converts the supplied US Cups value to Cubic Metres + /// # Arguments + /// * `value` - The US Cups input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 4166.67; + } + /// Converts the supplied US Cups value to Cubic Feet + /// # Arguments + /// * `value` - The US Cups input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 117.987; + } + /// Converts the supplied US Cups value to Cubic Inches + /// # Arguments + /// * `value` - The US Cups input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 14.6457; + } + /// Converts the supplied US Cups value to Oil Barrels + /// # Arguments + /// * `value` - The US Cups input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 662.447; + } } /// US Fluid Ounces conversion functions pub mod u_s_fluid_ounces { @@ -1028,6 +1736,30 @@ pub mod u_s_fluid_ounces { pub fn to_u_s_cups(value: f64) -> f64 { return value / 8.0; } + /// Converts the supplied US Fluid Ounces value to Cubic Metres + /// # Arguments + /// * `value` - The US Fluid Ounces input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 33814.0; + } + /// Converts the supplied US Fluid Ounces value to Cubic Feet + /// # Arguments + /// * `value` - The US Fluid Ounces input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 957.506; + } + /// Converts the supplied US Fluid Ounces value to Cubic Inches + /// # Arguments + /// * `value` - The US Fluid Ounces input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 1.80469; + } + /// Converts the supplied US Fluid Ounces value to Oil Barrels + /// # Arguments + /// * `value` - The US Fluid Ounces input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 5376.0; + } } /// US Gallons conversion functions pub mod u_s_gallons { @@ -1121,6 +1853,30 @@ pub mod u_s_gallons { pub fn to_u_s_cups(value: f64) -> f64 { return value * 16.0; } + /// Converts the supplied US Gallons value to Cubic Metres + /// # Arguments + /// * `value` - The US Gallons input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 264.172; + } + /// Converts the supplied US Gallons value to Cubic Feet + /// # Arguments + /// * `value` - The US Gallons input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 7.48052; + } + /// Converts the supplied US Gallons value to Cubic Inches + /// # Arguments + /// * `value` - The US Gallons input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 231.0; + } + /// Converts the supplied US Gallons value to Oil Barrels + /// # Arguments + /// * `value` - The US Gallons input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 42.0; + } } /// US Pints conversion functions pub mod u_s_pints { @@ -1214,6 +1970,30 @@ pub mod u_s_pints { pub fn to_u_s_cups(value: f64) -> f64 { return value * 2.0; } + /// Converts the supplied US Pints value to Cubic Metres + /// # Arguments + /// * `value` - The US Pints input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 2113.38; + } + /// Converts the supplied US Pints value to Cubic Feet + /// # Arguments + /// * `value` - The US Pints input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 59.8442; + } + /// Converts the supplied US Pints value to Cubic Inches + /// # Arguments + /// * `value` - The US Pints input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 28.875; + } + /// Converts the supplied US Pints value to Oil Barrels + /// # Arguments + /// * `value` - The US Pints input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 336.0; + } } /// US Quarts conversion functions pub mod u_s_quarts { @@ -1307,6 +2087,30 @@ pub mod u_s_quarts { pub fn to_u_s_cups(value: f64) -> f64 { return value * 4.0; } + /// Converts the supplied US Quarts value to Cubic Metres + /// # Arguments + /// * `value` - The US Quarts input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 1056.69; + } + /// Converts the supplied US Quarts value to Cubic Feet + /// # Arguments + /// * `value` - The US Quarts input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 29.9221; + } + /// Converts the supplied US Quarts value to Cubic Inches + /// # Arguments + /// * `value` - The US Quarts input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value * 57.75; + } + /// Converts the supplied US Quarts value to Oil Barrels + /// # Arguments + /// * `value` - The US Quarts input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 168.0; + } } /// US Tablespoons conversion functions pub mod u_s_tablespoons { @@ -1400,6 +2204,30 @@ pub mod u_s_tablespoons { pub fn to_u_s_cups(value: f64) -> f64 { return value / 16.0; } + /// Converts the supplied US Tablespoons value to Cubic Metres + /// # Arguments + /// * `value` - The US Tablespoons input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 67628.0; + } + /// Converts the supplied US Tablespoons value to Cubic Feet + /// # Arguments + /// * `value` - The US Tablespoons input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 1915.01; + } + /// Converts the supplied US Tablespoons value to Cubic Inches + /// # Arguments + /// * `value` - The US Tablespoons input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value / 1.10823; + } + /// Converts the supplied US Tablespoons value to Oil Barrels + /// # Arguments + /// * `value` - The US Tablespoons input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 10752.0; + } } /// US Teaspoons conversion functions pub mod u_s_teaspoons { @@ -1493,4 +2321,28 @@ pub mod u_s_teaspoons { pub fn to_u_s_cups(value: f64) -> f64 { return value / 48.0; } + /// Converts the supplied US Teaspoons value to Cubic Metres + /// # Arguments + /// * `value` - The US Teaspoons input value + pub fn to_cubic_metres(value: f64) -> f64 { + return value / 202884.0; + } + /// Converts the supplied US Teaspoons value to Cubic Feet + /// # Arguments + /// * `value` - The US Teaspoons input value + pub fn to_cubic_feet(value: f64) -> f64 { + return value / 5745.04; + } + /// Converts the supplied US Teaspoons value to Cubic Inches + /// # Arguments + /// * `value` - The US Teaspoons input value + pub fn to_cubic_inches(value: f64) -> f64 { + return value / 3.32468; + } + /// Converts the supplied US Teaspoons value to Oil Barrels + /// # Arguments + /// * `value` - The US Teaspoons input value + pub fn to_oil_barrels(value: f64) -> f64 { + return value / 32256.0; + } } diff --git a/tests/data_storage.rs b/tests/data_storage.rs index 129039c..2d47557 100644 --- a/tests/data_storage.rs +++ b/tests/data_storage.rs @@ -826,7 +826,7 @@ mod tests { #[test] fn it_convert_knownkibibits_to_terabytes_3() { let result: f64 = data_storage::kibibits::to_terabytes(9000000.0); - assert_approx_eq!(0.009216, result, 0.01); + assert_approx_eq!(0.001152, result, 0.01); } /// Need to convert to parameterized tests diff --git a/tests/data_transfer_rate.rs b/tests/data_transfer_rate.rs index 474ef24..62a4ed5 100644 --- a/tests/data_transfer_rate.rs +++ b/tests/data_transfer_rate.rs @@ -826,7 +826,7 @@ mod tests { #[test] fn it_convert_knownkibibits_per_second_to_tera_bytes_per_second_3() { let result: f64 = data_transfer_rate::kibibits_per_second::to_tera_bytes_per_second(9000000.0); - assert_approx_eq!(0.009216, result, 0.01); + assert_approx_eq!(0.001152, result, 0.01); } /// Need to convert to parameterized tests diff --git a/tests/volume.rs b/tests/volume.rs index b91726d..3e0198a 100644 --- a/tests/volume.rs +++ b/tests/volume.rs @@ -12,1577 +12,3593 @@ mod tests { /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_millilitres_1() { - let result: f64 = volume::fluid_ounces::to_millilitres(12.0); - assert_approx_eq!(340.957, result, 0.01); + fn it_convert_knowncubic_feet_to_millilitres_1() { + let result: f64 = volume::cubic_feet::to_millilitres(0.08); + assert_approx_eq!(2265.348, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_millilitres_2() { - let result: f64 = volume::fluid_ounces::to_millilitres(6.01); - assert_approx_eq!(170.7625, result, 0.01); + fn it_convert_knowncubic_feet_to_millilitres_2() { + let result: f64 = volume::cubic_feet::to_millilitres(6.0); + assert_approx_eq!(169900.79, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_millilitres_3() { - let result: f64 = volume::fluid_ounces::to_millilitres(0.78); - assert_approx_eq!(22.16219, result, 0.01); + fn it_convert_knowncubic_feet_to_millilitres_3() { + let result: f64 = volume::cubic_feet::to_millilitres(0.2393275); + assert_approx_eq!(6776.988, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_litres_1() { - let result: f64 = volume::fluid_ounces::to_litres(800.0); - assert_approx_eq!(22.7305, result, 0.01); + fn it_convert_knowncubic_feet_to_litres_1() { + let result: f64 = volume::cubic_feet::to_litres(0.3); + assert_approx_eq!(8.49505, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_litres_2() { - let result: f64 = volume::fluid_ounces::to_litres(4.5); - assert_approx_eq!(0.127859, result, 0.01); + fn it_convert_knowncubic_feet_to_litres_2() { + let result: f64 = volume::cubic_feet::to_litres(6.0); + assert_approx_eq!(169.901, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_litres_3() { - let result: f64 = volume::fluid_ounces::to_litres(109.0); - assert_approx_eq!(3.09702, result, 0.01); + fn it_convert_knowncubic_feet_to_litres_3() { + let result: f64 = volume::cubic_feet::to_litres(56.0); + assert_approx_eq!(1585.74, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_kilolitres_1() { - let result: f64 = volume::fluid_ounces::to_kilolitres(56909.0); - assert_approx_eq!(1.616959, result, 0.01); + fn it_convert_knowncubic_feet_to_kilolitres_1() { + let result: f64 = volume::cubic_feet::to_kilolitres(300.0); + assert_approx_eq!(8.49505, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_kilolitres_2() { - let result: f64 = volume::fluid_ounces::to_kilolitres(9009.0); - assert_approx_eq!(0.2559733, result, 0.01); + fn it_convert_knowncubic_feet_to_kilolitres_2() { + let result: f64 = volume::cubic_feet::to_kilolitres(141.259); + assert_approx_eq!(4.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_kilolitres_3() { - let result: f64 = volume::fluid_ounces::to_kilolitres(123456.0); - assert_approx_eq!(3.50776304, result, 0.01); + fn it_convert_knowncubic_feet_to_kilolitres_3() { + let result: f64 = volume::cubic_feet::to_kilolitres(111.0); + assert_approx_eq!(3.14317, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_teaspoons_1() { - let result: f64 = volume::fluid_ounces::to_teaspoons(123.0); - assert_approx_eq!(590.4, result, 0.01); + fn it_convert_knowncubic_feet_to_teaspoons_1() { + let result: f64 = volume::cubic_feet::to_teaspoons(0.3); + assert_approx_eq!(1435.12, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_teaspoons_2() { - let result: f64 = volume::fluid_ounces::to_teaspoons(9.12); - assert_approx_eq!(43.77598, result, 0.01); + fn it_convert_knowncubic_feet_to_teaspoons_2() { + let result: f64 = volume::cubic_feet::to_teaspoons(4.0); + assert_approx_eq!(19134.95, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_teaspoons_3() { - let result: f64 = volume::fluid_ounces::to_teaspoons(0.2); - assert_approx_eq!(0.96, result, 0.01); + fn it_convert_knowncubic_feet_to_teaspoons_3() { + let result: f64 = volume::cubic_feet::to_teaspoons(67.0); + assert_approx_eq!(320510.579, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_tablespoons_1() { - let result: f64 = volume::fluid_ounces::to_tablespoons(7.0); - assert_approx_eq!(11.2, result, 0.01); + fn it_convert_knowncubic_feet_to_tablespoons_1() { + let result: f64 = volume::cubic_feet::to_tablespoons(0.7); + assert_approx_eq!(1116.21, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_tablespoons_2() { - let result: f64 = volume::fluid_ounces::to_tablespoons(165.4); - assert_approx_eq!(264.63989, result, 0.01); + fn it_convert_knowncubic_feet_to_tablespoons_2() { + let result: f64 = volume::cubic_feet::to_tablespoons(1.1); + assert_approx_eq!(1754.04, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_tablespoons_3() { - let result: f64 = volume::fluid_ounces::to_tablespoons(80.1); - assert_approx_eq!(128.1599, result, 0.01); + fn it_convert_knowncubic_feet_to_tablespoons_3() { + let result: f64 = volume::cubic_feet::to_tablespoons(0.494174); + assert_approx_eq!(788.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_quarts_1() { - let result: f64 = volume::fluid_ounces::to_quarts(89.0); - assert_approx_eq!(2.225, result, 0.01); + fn it_convert_knowncubic_feet_to_quarts_1() { + let result: f64 = volume::cubic_feet::to_quarts(0.6); + assert_approx_eq!(14.9492, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_quarts_2() { - let result: f64 = volume::fluid_ounces::to_quarts(5.9); - assert_approx_eq!(0.1475, result, 0.01); + fn it_convert_knowncubic_feet_to_quarts_2() { + let result: f64 = volume::cubic_feet::to_quarts(0.20068); + assert_approx_eq!(5.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_quarts_3() { - let result: f64 = volume::fluid_ounces::to_quarts(1300.0); - assert_approx_eq!(32.5, result, 0.01); + fn it_convert_knowncubic_feet_to_quarts_3() { + let result: f64 = volume::cubic_feet::to_quarts(0.301019); + assert_approx_eq!(7.5, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_pints_1() { - let result: f64 = volume::fluid_ounces::to_pints(1300.0); - assert_approx_eq!(65.0, result, 0.01); + fn it_convert_knowncubic_feet_to_pints_1() { + let result: f64 = volume::cubic_feet::to_pints(0.6); + assert_approx_eq!(29.8984, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_pints_2() { - let result: f64 = volume::fluid_ounces::to_pints(5.7); - assert_approx_eq!(0.285, result, 0.01); + fn it_convert_knowncubic_feet_to_pints_2() { + let result: f64 = volume::cubic_feet::to_pints(0.88299); + assert_approx_eq!(44.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_pints_3() { - let result: f64 = volume::fluid_ounces::to_pints(1900.0); - assert_approx_eq!(95.0, result, 0.01); + fn it_convert_knowncubic_feet_to_pints_3() { + let result: f64 = volume::cubic_feet::to_pints(18.0612); + assert_approx_eq!(900.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_gallons_1() { - let result: f64 = volume::fluid_ounces::to_gallons(1900.0); - assert_approx_eq!(11.875, result, 0.01); + fn it_convert_knowncubic_feet_to_gallons_1() { + let result: f64 = volume::cubic_feet::to_gallons(3.0); + assert_approx_eq!(18.6865, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_gallons_2() { - let result: f64 = volume::fluid_ounces::to_gallons(5.6); - assert_approx_eq!(0.035, result, 0.01); + fn it_convert_knowncubic_feet_to_gallons_2() { + let result: f64 = volume::cubic_feet::to_gallons(2.08707); + assert_approx_eq!(13.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_gallons_3() { - let result: f64 = volume::fluid_ounces::to_gallons(12345.0); - assert_approx_eq!(77.15625, result, 0.01); + fn it_convert_knowncubic_feet_to_gallons_3() { + let result: f64 = volume::cubic_feet::to_gallons(14.1278); + assert_approx_eq!(88.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_teaspoons_1() { - let result: f64 = volume::fluid_ounces::to_u_s_teaspoons(12345.0); - assert_approx_eq!(71163.512, result, 0.01); + fn it_convert_knowncubic_feet_to_fluid_ounces_1() { + let result: f64 = volume::cubic_feet::to_fluid_ounces(14.0); + assert_approx_eq!(13952.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_teaspoons_2() { - let result: f64 = volume::fluid_ounces::to_u_s_teaspoons(8.9); - assert_approx_eq!(51.3046, result, 0.01); + fn it_convert_knowncubic_feet_to_fluid_ounces_2() { + let result: f64 = volume::cubic_feet::to_fluid_ounces(7.0); + assert_approx_eq!(6976.3, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_teaspoons_3() { - let result: f64 = volume::fluid_ounces::to_u_s_teaspoons(0.005); - assert_approx_eq!(0.028822808, result, 0.01); + fn it_convert_knowncubic_feet_to_fluid_ounces_3() { + let result: f64 = volume::cubic_feet::to_fluid_ounces(0.34777769); + assert_approx_eq!(346.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_tablespoons_1() { - let result: f64 = volume::fluid_ounces::to_u_s_tablespoons(190.0); - assert_approx_eq!(365.089, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_teaspoons_1() { + let result: f64 = volume::cubic_feet::to_u_s_teaspoons(5.0); + assert_approx_eq!(28725.2, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_tablespoons_2() { - let result: f64 = volume::fluid_ounces::to_u_s_tablespoons(6.8); - assert_approx_eq!(13.0663, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_teaspoons_2() { + let result: f64 = volume::cubic_feet::to_u_s_teaspoons(0.4); + assert_approx_eq!(2298.02, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_tablespoons_3() { - let result: f64 = volume::fluid_ounces::to_u_s_tablespoons(2340.0); - assert_approx_eq!(4496.357, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_teaspoons_3() { + let result: f64 = volume::cubic_feet::to_u_s_teaspoons(9.2); + assert_approx_eq!(52854.3679, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_quarts_1() { - let result: f64 = volume::fluid_ounces::to_u_s_quarts(45.0); - assert_approx_eq!(1.35107, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_tablespoons_1() { + let result: f64 = volume::cubic_feet::to_u_s_tablespoons(1.4); + assert_approx_eq!(2681.02, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_quarts_2() { - let result: f64 = volume::fluid_ounces::to_u_s_quarts(1090.0); - assert_approx_eq!(32.72589, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_tablespoons_2() { + let result: f64 = volume::cubic_feet::to_u_s_tablespoons(4.0); + assert_approx_eq!(7660.04, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_quarts_3() { - let result: f64 = volume::fluid_ounces::to_u_s_quarts(777.0); - assert_approx_eq!(23.3285, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_tablespoons_3() { + let result: f64 = volume::cubic_feet::to_u_s_tablespoons(0.6443821); + assert_approx_eq!(1234.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_pints_1() { - let result: f64 = volume::fluid_ounces::to_u_s_pints(678.0); - assert_approx_eq!(40.7122, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_quarts_1() { + let result: f64 = volume::cubic_feet::to_u_s_quarts(6.0); + assert_approx_eq!(179.532, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_pints_2() { - let result: f64 = volume::fluid_ounces::to_u_s_pints(4.5); - assert_approx_eq!(0.270214, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_quarts_2() { + let result: f64 = volume::cubic_feet::to_u_s_quarts(12.0); + assert_approx_eq!(359.065, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_pints_3() { - let result: f64 = volume::fluid_ounces::to_u_s_pints(1900.0); - assert_approx_eq!(114.0902, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_quarts_3() { + let result: f64 = volume::cubic_feet::to_u_s_quarts(25.9674); + assert_approx_eq!(777.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_gallons_1() { - let result: f64 = volume::fluid_ounces::to_u_s_gallons(1890.0); - assert_approx_eq!(14.18622, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_pints_1() { + let result: f64 = volume::cubic_feet::to_u_s_pints(6.9); + assert_approx_eq!(412.925, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_gallons_2() { - let result: f64 = volume::fluid_ounces::to_u_s_gallons(5.8); - assert_approx_eq!(0.0435344, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_pints_2() { + let result: f64 = volume::cubic_feet::to_u_s_pints(23.0); + assert_approx_eq!(1376.42, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_gallons_3() { - let result: f64 = volume::fluid_ounces::to_u_s_gallons(10090.0); - assert_approx_eq!(75.734905, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_pints_3() { + let result: f64 = volume::cubic_feet::to_u_s_pints(14.8385); + assert_approx_eq!(888.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_fluid_ounces_1() { - let result: f64 = volume::fluid_ounces::to_u_s_fluid_ounces(190.0); - assert_approx_eq!(182.544, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_gallons_1() { + let result: f64 = volume::cubic_feet::to_u_s_gallons(77.0); + assert_approx_eq!(576.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_fluid_ounces_2() { - let result: f64 = volume::fluid_ounces::to_u_s_fluid_ounces(54.8); - assert_approx_eq!(52.64964, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_gallons_2() { + let result: f64 = volume::cubic_feet::to_u_s_gallons(45.0); + assert_approx_eq!(336.623, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_fluid_ounces_3() { - let result: f64 = volume::fluid_ounces::to_u_s_fluid_ounces(1.7); - assert_approx_eq!(1.63329, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_gallons_3() { + let result: f64 = volume::cubic_feet::to_u_s_gallons(4.0); + assert_approx_eq!(29.9221, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_cups_1() { - let result: f64 = volume::fluid_ounces::to_u_s_cups(6.0); - assert_approx_eq!(0.72057, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_fluid_ounces_1() { + let result: f64 = volume::cubic_feet::to_u_s_fluid_ounces(20.0); + assert_approx_eq!(19150.119, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_cups_2() { - let result: f64 = volume::fluid_ounces::to_u_s_cups(1800.0); - assert_approx_eq!(216.171, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_fluid_ounces_2() { + let result: f64 = volume::cubic_feet::to_u_s_fluid_ounces(0.359266); + assert_approx_eq!(344.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownfluid_ounces_to_u_s_cups_3() { - let result: f64 = volume::fluid_ounces::to_u_s_cups(6.9); - assert_approx_eq!(0.828655, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_fluid_ounces_3() { + let result: f64 = volume::cubic_feet::to_u_s_fluid_ounces(0.699734); + assert_approx_eq!(670.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_millilitres_1() { - let result: f64 = volume::gallons::to_millilitres(1.3); - assert_approx_eq!(5909.92, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_cups_1() { + let result: f64 = volume::cubic_feet::to_u_s_cups(77.0); + assert_approx_eq!(9084.99, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_millilitres_2() { - let result: f64 = volume::gallons::to_millilitres(0.45); - assert_approx_eq!(2045.741, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_cups_2() { + let result: f64 = volume::cubic_feet::to_u_s_cups(8.0); + assert_approx_eq!(943.895, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_millilitres_3() { - let result: f64 = volume::gallons::to_millilitres(1.8); - assert_approx_eq!(8182.96, result, 0.01); + fn it_convert_knowncubic_feet_to_u_s_cups_3() { + let result: f64 = volume::cubic_feet::to_u_s_cups(4.79714); + assert_approx_eq!(566.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_litres_1() { - let result: f64 = volume::gallons::to_litres(123.0); - assert_approx_eq!(559.169, result, 0.01); + fn it_convert_knowncubic_feet_to_cubic_metres_1() { + let result: f64 = volume::cubic_feet::to_cubic_metres(28.2517); + assert_approx_eq!(0.8, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_litres_2() { - let result: f64 = volume::gallons::to_litres(9.3); - assert_approx_eq!(42.2786, result, 0.01); + fn it_convert_knowncubic_feet_to_cubic_metres_2() { + let result: f64 = volume::cubic_feet::to_cubic_metres(45.0); + assert_approx_eq!(1.27426, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_litres_3() { - let result: f64 = volume::gallons::to_litres(0.67); - assert_approx_eq!(3.04588, result, 0.01); + fn it_convert_knowncubic_feet_to_cubic_metres_3() { + let result: f64 = volume::cubic_feet::to_cubic_metres(2719.23); + assert_approx_eq!(77.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_kilolitres_1() { - let result: f64 = volume::gallons::to_kilolitres(1009.0); - assert_approx_eq!(4.587005, result, 0.01); + fn it_convert_knowncubic_feet_to_cubic_inches_1() { + let result: f64 = volume::cubic_feet::to_cubic_inches(6.8); + assert_approx_eq!(11750.4, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_kilolitres_2() { - let result: f64 = volume::gallons::to_kilolitres(9.6); - assert_approx_eq!(0.0436425, result, 0.01); + fn it_convert_knowncubic_feet_to_cubic_inches_2() { + let result: f64 = volume::cubic_feet::to_cubic_inches(5666.0); + assert_approx_eq!(9790848.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_kilolitres_3() { - let result: f64 = volume::gallons::to_kilolitres(123456.0); - assert_approx_eq!(561.242087, result, 0.01); + fn it_convert_knowncubic_feet_to_cubic_inches_3() { + let result: f64 = volume::cubic_feet::to_cubic_inches(0.7); + assert_approx_eq!(1209.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_teaspoons_1() { - let result: f64 = volume::gallons::to_teaspoons(6.0); - assert_approx_eq!(4608.0, result, 0.01); + fn it_convert_knowncubic_feet_to_oil_barrels_1() { + let result: f64 = volume::cubic_feet::to_oil_barrels(67.0); + assert_approx_eq!(11.9332, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_teaspoons_2() { - let result: f64 = volume::gallons::to_teaspoons(78.12); - assert_approx_eq!(59996.16, result, 0.01); + fn it_convert_knowncubic_feet_to_oil_barrels_2() { + let result: f64 = volume::cubic_feet::to_oil_barrels(44.0); + assert_approx_eq!(7.83673, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_teaspoons_3() { - let result: f64 = volume::gallons::to_teaspoons(0.34); - assert_approx_eq!(261.1199, result, 0.01); + fn it_convert_knowncubic_feet_to_oil_barrels_3() { + let result: f64 = volume::cubic_feet::to_oil_barrels(67.375); + assert_approx_eq!(12.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_tablespoons_1() { - let result: f64 = volume::gallons::to_tablespoons(0.9); - assert_approx_eq!(230.4, result, 0.01); + fn it_convert_knowncubic_inches_to_millilitres_1() { + let result: f64 = volume::cubic_inches::to_millilitres(3.9); + assert_approx_eq!(63.9095, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_tablespoons_2() { - let result: f64 = volume::gallons::to_tablespoons(1.6); - assert_approx_eq!(409.6, result, 0.01); + fn it_convert_knowncubic_inches_to_millilitres_2() { + let result: f64 = volume::cubic_inches::to_millilitres(4.0); + assert_approx_eq!(65.5483, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_tablespoons_3() { - let result: f64 = volume::gallons::to_tablespoons(0.33); - assert_approx_eq!(84.47997, result, 0.01); + fn it_convert_knowncubic_inches_to_millilitres_3() { + let result: f64 = volume::cubic_inches::to_millilitres(5.37009); + assert_approx_eq!(88.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_quarts_1() { - let result: f64 = volume::gallons::to_quarts(109.0); - assert_approx_eq!(436.0, result, 0.01); + fn it_convert_knowncubic_inches_to_litres_1() { + let result: f64 = volume::cubic_inches::to_litres(560.0); + assert_approx_eq!(9.17676, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_quarts_2() { - let result: f64 = volume::gallons::to_quarts(5.8); - assert_approx_eq!(23.2, result, 0.01); + fn it_convert_knowncubic_inches_to_litres_2() { + let result: f64 = volume::cubic_inches::to_litres(555.0); + assert_approx_eq!(9.09482, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_quarts_3() { - let result: f64 = volume::gallons::to_quarts(0.23); - assert_approx_eq!(0.92, result, 0.01); + fn it_convert_knowncubic_inches_to_litres_3() { + let result: f64 = volume::cubic_inches::to_litres(7444.9); + assert_approx_eq!(122.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_pints_1() { - let result: f64 = volume::gallons::to_pints(0.23); - assert_approx_eq!(1.84, result, 0.01); + fn it_convert_knowncubic_inches_to_kilolitres_1() { + let result: f64 = volume::cubic_inches::to_kilolitres(560.0); + assert_approx_eq!(0.009176, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_pints_2() { - let result: f64 = volume::gallons::to_pints(190.0); - assert_approx_eq!(1520.0, result, 0.01); + fn it_convert_knowncubic_inches_to_kilolitres_2() { + let result: f64 = volume::cubic_inches::to_kilolitres(5555.0); + assert_approx_eq!(0.09103014, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_pints_3() { - let result: f64 = volume::gallons::to_pints(24.7); - assert_approx_eq!(197.6, result, 0.01); + fn it_convert_knowncubic_inches_to_kilolitres_3() { + let result: f64 = volume::cubic_inches::to_kilolitres(100000.0); + assert_approx_eq!(1.6387064, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_fluid_ounces_1() { - let result: f64 = volume::gallons::to_fluid_ounces(24.7); - assert_approx_eq!(3952.0, result, 0.01); + fn it_convert_knowncubic_inches_to_teaspoons_1() { + let result: f64 = volume::cubic_inches::to_teaspoons(5.0); + assert_approx_eq!(13.8419, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_fluid_ounces_2() { - let result: f64 = volume::gallons::to_fluid_ounces(13.09); - assert_approx_eq!(2094.4, result, 0.01); + fn it_convert_knowncubic_inches_to_teaspoons_2() { + let result: f64 = volume::cubic_inches::to_teaspoons(6.0); + assert_approx_eq!(16.6102, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_fluid_ounces_3() { - let result: f64 = volume::gallons::to_fluid_ounces(5.8); - assert_approx_eq!(928.0, result, 0.01); + fn it_convert_knowncubic_inches_to_teaspoons_3() { + let result: f64 = volume::cubic_inches::to_teaspoons(11.5591); + assert_approx_eq!(32.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_teaspoons_1() { - let result: f64 = volume::gallons::to_u_s_teaspoons(5.8); - assert_approx_eq!(5349.51, result, 0.01); + fn it_convert_knowncubic_inches_to_tablespoons_1() { + let result: f64 = volume::cubic_inches::to_tablespoons(34.0); + assert_approx_eq!(31.3749, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_teaspoons_2() { - let result: f64 = volume::gallons::to_u_s_teaspoons(0.44); - assert_approx_eq!(405.8251, result, 0.01); + fn it_convert_knowncubic_inches_to_tablespoons_2() { + let result: f64 = volume::cubic_inches::to_tablespoons(11.9204); + assert_approx_eq!(11.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_teaspoons_3() { - let result: f64 = volume::gallons::to_u_s_teaspoons(1.9); - assert_approx_eq!(1752.43, result, 0.01); + fn it_convert_knowncubic_inches_to_tablespoons_3() { + let result: f64 = volume::cubic_inches::to_tablespoons(99.0); + assert_approx_eq!(91.3562246, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_tablespoons_1() { - let result: f64 = volume::gallons::to_u_s_tablespoons(1.8); - assert_approx_eq!(553.398, result, 0.01); + fn it_convert_knowncubic_inches_to_quarts_1() { + let result: f64 = volume::cubic_inches::to_quarts(800.0); + assert_approx_eq!(11.5349, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_tablespoons_2() { - let result: f64 = volume::gallons::to_u_s_tablespoons(0.33); - assert_approx_eq!(101.4562, result, 0.01); + fn it_convert_knowncubic_inches_to_quarts_2() { + let result: f64 = volume::cubic_inches::to_quarts(77.0); + assert_approx_eq!(1.11023, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_tablespoons_3() { - let result: f64 = volume::gallons::to_u_s_tablespoons(100.0); - assert_approx_eq!(30744.33080, result, 0.01); + fn it_convert_knowncubic_inches_to_quarts_3() { + let result: f64 = volume::cubic_inches::to_quarts(4577.42); + assert_approx_eq!(66.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_quarts_1() { - let result: f64 = volume::gallons::to_u_s_quarts(78.0); - assert_approx_eq!(374.696, result, 0.01); + fn it_convert_knowncubic_inches_to_pints_1() { + let result: f64 = volume::cubic_inches::to_pints(89.5); + assert_approx_eq!(2.58093, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_quarts_2() { - let result: f64 = volume::gallons::to_u_s_quarts(1.7); - assert_approx_eq!(8.16646, result, 0.01); + fn it_convert_knowncubic_inches_to_pints_2() { + let result: f64 = volume::cubic_inches::to_pints(23095.2); + assert_approx_eq!(666.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_quarts_3() { - let result: f64 = volume::gallons::to_u_s_quarts(16.9); - assert_approx_eq!(81.18421, result, 0.01); + fn it_convert_knowncubic_inches_to_pints_3() { + let result: f64 = volume::cubic_inches::to_pints(2670.16); + assert_approx_eq!(77.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_pints_1() { - let result: f64 = volume::gallons::to_u_s_pints(13.4); - assert_approx_eq!(128.7418, result, 0.01); + fn it_convert_knowncubic_inches_to_gallons_1() { + let result: f64 = volume::cubic_inches::to_gallons(900.0); + assert_approx_eq!(3.24419, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_pints_2() { - let result: f64 = volume::gallons::to_u_s_pints(8.12); - assert_approx_eq!(78.01371, result, 0.01); + fn it_convert_knowncubic_inches_to_gallons_2() { + let result: f64 = volume::cubic_inches::to_gallons(666.0); + assert_approx_eq!(2.4007, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_pints_3() { - let result: f64 = volume::gallons::to_u_s_pints(0.99); - assert_approx_eq!(9.511523, result, 0.01); + fn it_convert_knowncubic_inches_to_gallons_3() { + let result: f64 = volume::cubic_inches::to_gallons(21361.3); + assert_approx_eq!(77.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_gallons_1() { - let result: f64 = volume::gallons::to_u_s_gallons(1.5); - assert_approx_eq!(1.80142, result, 0.01); + fn it_convert_knowncubic_inches_to_fluid_ounces_1() { + let result: f64 = volume::cubic_inches::to_fluid_ounces(77.0); + assert_approx_eq!(44.4093, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_gallons_2() { - let result: f64 = volume::gallons::to_u_s_gallons(0.78); - assert_approx_eq!(0.9367409, result, 0.01); + fn it_convert_knowncubic_inches_to_fluid_ounces_2() { + let result: f64 = volume::cubic_inches::to_fluid_ounces(55.0); + assert_approx_eq!(31.7209, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_gallons_3() { - let result: f64 = volume::gallons::to_u_s_gallons(103.0); - assert_approx_eq!(123.698, result, 0.01); + fn it_convert_knowncubic_inches_to_fluid_ounces_3() { + let result: f64 = volume::cubic_inches::to_fluid_ounces(27.7419); + assert_approx_eq!(16.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_fluid_ounces_1() { - let result: f64 = volume::gallons::to_u_s_fluid_ounces(111.0); - assert_approx_eq!(17063.1, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_teaspoons_1() { + let result: f64 = volume::cubic_inches::to_u_s_teaspoons(678.0); + assert_approx_eq!(2254.13, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_fluid_ounces_2() { - let result: f64 = volume::gallons::to_u_s_fluid_ounces(89.9); - assert_approx_eq!(13819.57, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_teaspoons_2() { + let result: f64 = volume::cubic_inches::to_u_s_teaspoons(55.0); + assert_approx_eq!(182.857, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_fluid_ounces_3() { - let result: f64 = volume::gallons::to_u_s_fluid_ounces(1.2); - assert_approx_eq!(184.466, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_teaspoons_3() { + let result: f64 = volume::cubic_inches::to_u_s_teaspoons(26.4687); + assert_approx_eq!(88.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_cups_1() { - let result: f64 = volume::gallons::to_u_s_cups(1.2); - assert_approx_eq!(23.0582, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_tablespoons_1() { + let result: f64 = volume::cubic_inches::to_u_s_tablespoons(66.0); + assert_approx_eq!(73.1429, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_cups_2() { - let result: f64 = volume::gallons::to_u_s_cups(0.55); - assert_approx_eq!(10.56836, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_tablespoons_2() { + let result: f64 = volume::cubic_inches::to_u_s_tablespoons(55.0); + assert_approx_eq!(60.9524, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knowngallons_to_u_s_cups_3() { - let result: f64 = volume::gallons::to_u_s_cups(890.0); - assert_approx_eq!(17101.534007630, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_tablespoons_3() { + let result: f64 = volume::cubic_inches::to_u_s_tablespoons(10.8281); + assert_approx_eq!(12.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_millilitres_1() { - let result: f64 = volume::kilolitres::to_millilitres(0.09); - assert_approx_eq!(90000.0, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_quarts_1() { + let result: f64 = volume::cubic_inches::to_u_s_quarts(345.0); + assert_approx_eq!(5.97403, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_millilitres_2() { - let result: f64 = volume::kilolitres::to_millilitres(0.00123); - assert_approx_eq!(1230.0, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_quarts_2() { + let result: f64 = volume::cubic_inches::to_u_s_quarts(33.0); + assert_approx_eq!(0.571429, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_millilitres_3() { - let result: f64 = volume::kilolitres::to_millilitres(1.2); - assert_approx_eq!(1.2e+6, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_quarts_3() { + let result: f64 = volume::cubic_inches::to_u_s_quarts(3176.25); + assert_approx_eq!(55.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_litres_1() { - let result: f64 = volume::kilolitres::to_litres(1.2); - assert_approx_eq!(1200.0, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_pints_1() { + let result: f64 = volume::cubic_inches::to_u_s_pints(89.0); + assert_approx_eq!(3.08225, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_litres_2() { - let result: f64 = volume::kilolitres::to_litres(0.8); - assert_approx_eq!(800.0, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_pints_2() { + let result: f64 = volume::cubic_inches::to_u_s_pints(3176.25); + assert_approx_eq!(110.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_litres_3() { - let result: f64 = volume::kilolitres::to_litres(456.0); - assert_approx_eq!(456000.0, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_pints_3() { + let result: f64 = volume::cubic_inches::to_u_s_pints(462.0); + assert_approx_eq!(16.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_teaspoons_1() { - let result: f64 = volume::kilolitres::to_teaspoons(0.7); - assert_approx_eq!(118255.41900799, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_gallons_1() { + let result: f64 = volume::cubic_inches::to_u_s_gallons(600.0); + assert_approx_eq!(2.5974, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_teaspoons_2() { - let result: f64 = volume::kilolitres::to_teaspoons(0.01); - assert_approx_eq!(1689.363, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_gallons_2() { + let result: f64 = volume::cubic_inches::to_u_s_gallons(462.0); + assert_approx_eq!(2.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_teaspoons_3() { - let result: f64 = volume::kilolitres::to_teaspoons(4.5); - assert_approx_eq!(760213.407908, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_gallons_3() { + let result: f64 = volume::cubic_inches::to_u_s_gallons(899.0); + assert_approx_eq!(3.89177, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_tablespoons_1() { - let result: f64 = volume::kilolitres::to_tablespoons(0.3); - assert_approx_eq!(16893.631286856, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_fluid_ounces_1() { + let result: f64 = volume::cubic_inches::to_u_s_fluid_ounces(900.0); + assert_approx_eq!(498.700607, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_tablespoons_2() { - let result: f64 = volume::kilolitres::to_tablespoons(2.9); - assert_approx_eq!(163305.10243961, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_fluid_ounces_2() { + let result: f64 = volume::cubic_inches::to_u_s_fluid_ounces(777.0); + assert_approx_eq!(430.544858, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_tablespoons_3() { - let result: f64 = volume::kilolitres::to_tablespoons(0.067); - assert_approx_eq!(3772.911, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_fluid_ounces_3() { + let result: f64 = volume::cubic_inches::to_u_s_fluid_ounces(178.664); + assert_approx_eq!(98.99982822, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_quarts_1() { - let result: f64 = volume::kilolitres::to_quarts(0.09); - assert_approx_eq!(79.18893, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_cups_1() { + let result: f64 = volume::cubic_inches::to_u_s_cups(7.0); + assert_approx_eq!(0.477956, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_quarts_2() { - let result: f64 = volume::kilolitres::to_quarts(2.3); - assert_approx_eq!(2023.72, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_cups_2() { + let result: f64 = volume::cubic_inches::to_u_s_cups(77.0); + assert_approx_eq!(5.25752, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_quarts_3() { - let result: f64 = volume::kilolitres::to_quarts(0.67); - assert_approx_eq!(589.5176, result, 0.01); + fn it_convert_knowncubic_inches_to_u_s_cups_3() { + let result: f64 = volume::cubic_inches::to_u_s_cups(123.0); + assert_approx_eq!(8.39837, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_pints_1() { - let result: f64 = volume::kilolitres::to_pints(0.4); - assert_approx_eq!(703.902, result, 0.01); + fn it_convert_knowncubic_inches_to_cubic_metres_1() { + let result: f64 = volume::cubic_inches::to_cubic_metres(24409.5); + assert_approx_eq!(0.4, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_pints_2() { - let result: f64 = volume::kilolitres::to_pints(67.0); - assert_approx_eq!(117903.46835618, result, 0.01); + fn it_convert_knowncubic_inches_to_cubic_metres_2() { + let result: f64 = volume::cubic_inches::to_cubic_metres(7777.0); + assert_approx_eq!(0.1274422, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_pints_3() { - let result: f64 = volume::kilolitres::to_pints(9.3); - assert_approx_eq!(16365.7, result, 0.01); + fn it_convert_knowncubic_inches_to_cubic_metres_3() { + let result: f64 = volume::cubic_inches::to_cubic_metres(366142.0); + assert_approx_eq!(6.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_gallons_1() { - let result: f64 = volume::kilolitres::to_gallons(109.0); - assert_approx_eq!(23976.638149, result, 0.01); + fn it_convert_knowncubic_inches_to_cubic_feet_1() { + let result: f64 = volume::cubic_inches::to_cubic_feet(11750.4); + assert_approx_eq!(6.8, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_gallons_2() { - let result: f64 = volume::kilolitres::to_gallons(7.2); - assert_approx_eq!(1583.78, result, 0.01); + fn it_convert_knowncubic_inches_to_cubic_feet_2() { + let result: f64 = volume::cubic_inches::to_cubic_feet(57024.0); + assert_approx_eq!(33.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_gallons_3() { - let result: f64 = volume::kilolitres::to_gallons(0.4); - assert_approx_eq!(87.9877, result, 0.01); + fn it_convert_knowncubic_inches_to_cubic_feet_3() { + let result: f64 = volume::cubic_inches::to_cubic_feet(1234.0); + assert_approx_eq!(0.7141204, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_fluid_ounces_1() { - let result: f64 = volume::kilolitres::to_fluid_ounces(0.2); - assert_approx_eq!(7039.02, result, 0.01); + fn it_convert_knowncubic_inches_to_oil_barrels_1() { + let result: f64 = volume::cubic_inches::to_oil_barrels(90000.0); + assert_approx_eq!(9.2764378, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_fluid_ounces_2() { - let result: f64 = volume::kilolitres::to_fluid_ounces(4.8); - assert_approx_eq!(168936.31286856, result, 0.01); + fn it_convert_knowncubic_inches_to_oil_barrels_2() { + let result: f64 = volume::cubic_inches::to_oil_barrels(8888.0); + assert_approx_eq!(0.9160998, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_fluid_ounces_3() { - let result: f64 = volume::kilolitres::to_fluid_ounces(6.0); - assert_approx_eq!(211170.391085, result, 0.01); + fn it_convert_knowncubic_inches_to_oil_barrels_3() { + let result: f64 = volume::cubic_inches::to_oil_barrels(11642.4); + assert_approx_eq!(1.2, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_teaspoons_1() { - let result: f64 = volume::kilolitres::to_u_s_teaspoons(4.0); - assert_approx_eq!(811536.5448442, result, 0.01); + fn it_convert_knowncubic_metres_to_millilitres_1() { + let result: f64 = volume::cubic_metres::to_millilitres(0.01); + assert_approx_eq!(10000.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_teaspoons_2() { - let result: f64 = volume::kilolitres::to_u_s_teaspoons(0.2); - assert_approx_eq!(40576.82724221160, result, 0.01); + fn it_convert_knowncubic_metres_to_millilitres_2() { + let result: f64 = volume::cubic_metres::to_millilitres(0.2306735); + assert_approx_eq!(230673.5, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_teaspoons_3() { - let result: f64 = volume::kilolitres::to_u_s_teaspoons(2.4); - assert_approx_eq!(486921.92690653, result, 0.01); + fn it_convert_knowncubic_metres_to_millilitres_3() { + let result: f64 = volume::cubic_metres::to_millilitres(0.009); + assert_approx_eq!(9000.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_tablespoons_1() { - let result: f64 = volume::kilolitres::to_u_s_tablespoons(1.3); - assert_approx_eq!(87916.45902479, result, 0.01); + fn it_convert_knowncubic_metres_to_litres_1() { + let result: f64 = volume::cubic_metres::to_litres(0.1); + assert_approx_eq!(100.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_tablespoons_2() { - let result: f64 = volume::kilolitres::to_u_s_tablespoons(0.6); - assert_approx_eq!(40576.82724221, result, 0.01); + fn it_convert_knowncubic_metres_to_litres_2() { + let result: f64 = volume::cubic_metres::to_litres(0.009); + assert_approx_eq!(9.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_tablespoons_3() { - let result: f64 = volume::kilolitres::to_u_s_tablespoons(0.03); - assert_approx_eq!(2028.841, result, 0.01); + fn it_convert_knowncubic_metres_to_litres_3() { + let result: f64 = volume::cubic_metres::to_litres(0.08989); + assert_approx_eq!(89.89, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_quarts_1() { - let result: f64 = volume::kilolitres::to_u_s_quarts(0.09); - assert_approx_eq!(95.10194, result, 0.01); + fn it_convert_knowncubic_metres_to_kilolitres_1() { + let result: f64 = volume::cubic_metres::to_kilolitres(0.9); + assert_approx_eq!(0.9, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_quarts_2() { - let result: f64 = volume::kilolitres::to_u_s_quarts(2.5); - assert_approx_eq!(2641.72, result, 0.01); + fn it_convert_knowncubic_metres_to_kilolitres_2() { + let result: f64 = volume::cubic_metres::to_kilolitres(100.9); + assert_approx_eq!(100.9, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_quarts_3() { - let result: f64 = volume::kilolitres::to_u_s_quarts(178.9); - assert_approx_eq!(189041.52, result, 0.01); + fn it_convert_knowncubic_metres_to_kilolitres_3() { + let result: f64 = volume::cubic_metres::to_kilolitres(666.9); + assert_approx_eq!(666.9, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_pints_1() { - let result: f64 = volume::kilolitres::to_u_s_pints(67.0); - assert_approx_eq!(141596.2200639, result, 0.01); + fn it_convert_knowncubic_metres_to_teaspoons_1() { + let result: f64 = volume::cubic_metres::to_teaspoons(0.1); + assert_approx_eq!(16893.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_pints_2() { - let result: f64 = volume::kilolitres::to_u_s_pints(4.7); - assert_approx_eq!(9932.87, result, 0.01); + fn it_convert_knowncubic_metres_to_teaspoons_2() { + let result: f64 = volume::cubic_metres::to_teaspoons(3.0); + assert_approx_eq!(506808.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_pints_3() { - let result: f64 = volume::kilolitres::to_u_s_pints(108.9); - assert_approx_eq!(230146.69, result, 0.01); + fn it_convert_knowncubic_metres_to_teaspoons_3() { + let result: f64 = volume::cubic_metres::to_teaspoons(0.91); + assert_approx_eq!(153731.76, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_gallons_1() { - let result: f64 = volume::kilolitres::to_u_s_gallons(1.6); - assert_approx_eq!(422.675, result, 0.01); + fn it_convert_knowncubic_metres_to_tablespoons_1() { + let result: f64 = volume::cubic_metres::to_tablespoons(0.9); + assert_approx_eq!(50680.8899, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_gallons_2() { - let result: f64 = volume::kilolitres::to_u_s_gallons(57.0); - assert_approx_eq!(15057.8, result, 0.01); + fn it_convert_knowncubic_metres_to_tablespoons_2() { + let result: f64 = volume::cubic_metres::to_tablespoons(0.1); + assert_approx_eq!(5631.21, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_gallons_3() { - let result: f64 = volume::kilolitres::to_u_s_gallons(0.88); - assert_approx_eq!(232.4714, result, 0.01); + fn it_convert_knowncubic_metres_to_tablespoons_3() { + let result: f64 = volume::cubic_metres::to_tablespoons(9.0); + assert_approx_eq!(506808.89, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_fluid_ounces_1() { - let result: f64 = volume::kilolitres::to_u_s_fluid_ounces(0.07); - assert_approx_eq!(2366.982, result, 0.01); + fn it_convert_knowncubic_metres_to_quarts_1() { + let result: f64 = volume::cubic_metres::to_quarts(0.8); + assert_approx_eq!(703.902, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_fluid_ounces_2() { - let result: f64 = volume::kilolitres::to_u_s_fluid_ounces(4.2); - assert_approx_eq!(142018.89516765, result, 0.01); + fn it_convert_knowncubic_metres_to_quarts_2() { + let result: f64 = volume::cubic_metres::to_quarts(0.4); + assert_approx_eq!(351.951, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_fluid_ounces_3() { - let result: f64 = volume::kilolitres::to_u_s_fluid_ounces(12.0); - assert_approx_eq!(405768.27190759, result, 0.01); + fn it_convert_knowncubic_metres_to_quarts_3() { + let result: f64 = volume::cubic_metres::to_quarts(6.0); + assert_approx_eq!(5279.26, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_cups_1() { - let result: f64 = volume::kilolitres::to_u_s_cups(12.0); - assert_approx_eq!(50721.03405276, result, 0.01); + fn it_convert_knowncubic_metres_to_pints_1() { + let result: f64 = volume::cubic_metres::to_pints(0.7); + assert_approx_eq!(1231.83, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_cups_2() { - let result: f64 = volume::kilolitres::to_u_s_cups(0.8); - assert_approx_eq!(3381.4, result, 0.01); + fn it_convert_knowncubic_metres_to_pints_2() { + let result: f64 = volume::cubic_metres::to_pints(4.5); + assert_approx_eq!(7918.875, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownkilolitres_to_u_s_cups_3() { - let result: f64 = volume::kilolitres::to_u_s_cups(6.2); - assert_approx_eq!(26205.86759392, result, 0.01); + fn it_convert_knowncubic_metres_to_pints_3() { + let result: f64 = volume::cubic_metres::to_pints(0.06); + assert_approx_eq!(105.5852, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_millilitres_1() { - let result: f64 = volume::litres::to_millilitres(34.0); - assert_approx_eq!(34000.0, result, 0.01); + fn it_convert_knowncubic_metres_to_gallons_1() { + let result: f64 = volume::cubic_metres::to_gallons(0.2); + assert_approx_eq!(43.9938, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_millilitres_2() { - let result: f64 = volume::litres::to_millilitres(0.67); - assert_approx_eq!(670.0, result, 0.01); + fn it_convert_knowncubic_metres_to_gallons_2() { + let result: f64 = volume::cubic_metres::to_gallons(0.4); + assert_approx_eq!(87.9877, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_millilitres_3() { - let result: f64 = volume::litres::to_millilitres(1.09); - assert_approx_eq!(1090.0, result, 0.01); + fn it_convert_knowncubic_metres_to_gallons_3() { + let result: f64 = volume::cubic_metres::to_gallons(0.0272765); + assert_approx_eq!(6.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_kilolitres_1() { - let result: f64 = volume::litres::to_kilolitres(200.0); - assert_approx_eq!(0.2, result, 0.01); + fn it_convert_knowncubic_metres_to_fluid_ounces_1() { + let result: f64 = volume::cubic_metres::to_fluid_ounces(0.7); + assert_approx_eq!(24636.569, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_kilolitres_2() { - let result: f64 = volume::litres::to_kilolitres(12345.0); - assert_approx_eq!(12.345, result, 0.01); + fn it_convert_knowncubic_metres_to_fluid_ounces_2() { + let result: f64 = volume::cubic_metres::to_fluid_ounces(0.09); + assert_approx_eq!(3167.557, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_kilolitres_3() { - let result: f64 = volume::litres::to_kilolitres(80.0); - assert_approx_eq!(0.08, result, 0.01); + fn it_convert_knowncubic_metres_to_fluid_ounces_3() { + let result: f64 = volume::cubic_metres::to_fluid_ounces(4.0); + assert_approx_eq!(140780.399, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_teaspoons_1() { - let result: f64 = volume::litres::to_teaspoons(3.0); - assert_approx_eq!(506.809, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_teaspoons_1() { + let result: f64 = volume::cubic_metres::to_u_s_teaspoons(0.5); + assert_approx_eq!(101442.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_teaspoons_2() { - let result: f64 = volume::litres::to_teaspoons(0.2); - assert_approx_eq!(33.7873, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_teaspoons_2() { + let result: f64 = volume::cubic_metres::to_u_s_teaspoons(2.0); + assert_approx_eq!(405768.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_teaspoons_3() { - let result: f64 = volume::litres::to_teaspoons(4.2); - assert_approx_eq!(709.533, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_teaspoons_3() { + let result: f64 = volume::cubic_metres::to_u_s_teaspoons(0.3); + assert_approx_eq!(60865.199, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_tablespoons_1() { - let result: f64 = volume::litres::to_tablespoons(3.0); - assert_approx_eq!(168.936, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_tablespoons_1() { + let result: f64 = volume::cubic_metres::to_u_s_tablespoons(0.2); + assert_approx_eq!(13525.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_tablespoons_2() { - let result: f64 = volume::litres::to_tablespoons(0.4); - assert_approx_eq!(22.5248, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_tablespoons_2() { + let result: f64 = volume::cubic_metres::to_u_s_tablespoons(0.9); + assert_approx_eq!(60865.2, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_tablespoons_3() { - let result: f64 = volume::litres::to_tablespoons(67.0); - assert_approx_eq!(3772.91, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_tablespoons_3() { + let result: f64 = volume::cubic_metres::to_u_s_tablespoons(2.0); + assert_approx_eq!(135256.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_quarts_1() { - let result: f64 = volume::litres::to_quarts(54.0); - assert_approx_eq!(47.5134, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_quarts_1() { + let result: f64 = volume::cubic_metres::to_u_s_quarts(0.2); + assert_approx_eq!(211.338, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_quarts_2() { - let result: f64 = volume::litres::to_quarts(2.0); - assert_approx_eq!(1.75975, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_quarts_2() { + let result: f64 = volume::cubic_metres::to_u_s_quarts(4.0); + assert_approx_eq!(4226.76, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_quarts_3() { - let result: f64 = volume::litres::to_quarts(0.7); - assert_approx_eq!(0.615914, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_quarts_3() { + let result: f64 = volume::cubic_metres::to_u_s_quarts(0.851718); + assert_approx_eq!(900.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_pints_1() { - let result: f64 = volume::litres::to_pints(0.5); - assert_approx_eq!(0.879877, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_pints_1() { + let result: f64 = volume::cubic_metres::to_u_s_pints(0.4); + assert_approx_eq!(845.351, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_pints_2() { - let result: f64 = volume::litres::to_pints(145.0); - assert_approx_eq!(255.164, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_pints_2() { + let result: f64 = volume::cubic_metres::to_u_s_pints(7.0); + assert_approx_eq!(14793.66, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_pints_3() { - let result: f64 = volume::litres::to_pints(9.1); - assert_approx_eq!(16.0138, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_pints_3() { + let result: f64 = volume::cubic_metres::to_u_s_pints(6.0); + assert_approx_eq!(12680.280, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_gallons_1() { - let result: f64 = volume::litres::to_gallons(12.9); - assert_approx_eq!(2.837603, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_gallons_1() { + let result: f64 = volume::cubic_metres::to_u_s_gallons(0.7); + assert_approx_eq!(184.92, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_gallons_2() { - let result: f64 = volume::litres::to_gallons(109.0); - assert_approx_eq!(23.9766, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_gallons_2() { + let result: f64 = volume::cubic_metres::to_u_s_gallons(0.851718); + assert_approx_eq!(225.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_gallons_3() { - let result: f64 = volume::litres::to_gallons(67.0); - assert_approx_eq!(14.7379, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_gallons_3() { + let result: f64 = volume::cubic_metres::to_u_s_gallons(0.02); + assert_approx_eq!(5.283441, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_fluid_ounces_1() { - let result: f64 = volume::litres::to_fluid_ounces(5.0); - assert_approx_eq!(175.975, result, 0.01); + fn it_convert_knowncubic_metres_to_u_s_fluid_ounces_1() { + let result: f64 = volume::cubic_metres::to_u_s_fluid_ounces(0.9); + assert_approx_eq!(30432.6, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_u_s_fluid_ounces_2() { + let result: f64 = volume::cubic_metres::to_u_s_fluid_ounces(0.3); + assert_approx_eq!(10144.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_u_s_fluid_ounces_3() { + let result: f64 = volume::cubic_metres::to_u_s_fluid_ounces(3.3); + assert_approx_eq!(111586.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_u_s_cups_1() { + let result: f64 = volume::cubic_metres::to_u_s_cups(7.0); + assert_approx_eq!(29166.7, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_u_s_cups_2() { + let result: f64 = volume::cubic_metres::to_u_s_cups(11.0); + assert_approx_eq!(45833.37, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_u_s_cups_3() { + let result: f64 = volume::cubic_metres::to_u_s_cups(66.0); + assert_approx_eq!(275000.22, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_cubic_feet_1() { + let result: f64 = volume::cubic_metres::to_cubic_feet(0.8); + assert_approx_eq!(28.2517, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_cubic_feet_2() { + let result: f64 = volume::cubic_metres::to_cubic_feet(5.0); + assert_approx_eq!(176.573, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_cubic_feet_3() { + let result: f64 = volume::cubic_metres::to_cubic_feet(12.12); + assert_approx_eq!(428.014163, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_cubic_inches_1() { + let result: f64 = volume::cubic_metres::to_cubic_inches(0.4); + assert_approx_eq!(24409.48, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_cubic_inches_2() { + let result: f64 = volume::cubic_metres::to_cubic_inches(3.0); + assert_approx_eq!(183071.099, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_cubic_inches_3() { + let result: f64 = volume::cubic_metres::to_cubic_inches(0.99); + assert_approx_eq!(60413.4629, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_oil_barrels_1() { + let result: f64 = volume::cubic_metres::to_oil_barrels(0.09); + assert_approx_eq!(0.566083, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_oil_barrels_2() { + let result: f64 = volume::cubic_metres::to_oil_barrels(5.0); + assert_approx_eq!(31.4491, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowncubic_metres_to_oil_barrels_3() { + let result: f64 = volume::cubic_metres::to_oil_barrels(1.2); + assert_approx_eq!(7.547772, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_millilitres_1() { + let result: f64 = volume::fluid_ounces::to_millilitres(12.0); + assert_approx_eq!(340.957, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_millilitres_2() { + let result: f64 = volume::fluid_ounces::to_millilitres(6.01); + assert_approx_eq!(170.7625, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_millilitres_3() { + let result: f64 = volume::fluid_ounces::to_millilitres(0.78); + assert_approx_eq!(22.16219, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_litres_1() { + let result: f64 = volume::fluid_ounces::to_litres(800.0); + assert_approx_eq!(22.7305, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_litres_2() { + let result: f64 = volume::fluid_ounces::to_litres(4.5); + assert_approx_eq!(0.127859, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_litres_3() { + let result: f64 = volume::fluid_ounces::to_litres(109.0); + assert_approx_eq!(3.09702, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_kilolitres_1() { + let result: f64 = volume::fluid_ounces::to_kilolitres(56909.0); + assert_approx_eq!(1.616959, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_kilolitres_2() { + let result: f64 = volume::fluid_ounces::to_kilolitres(9009.0); + assert_approx_eq!(0.2559733, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_kilolitres_3() { + let result: f64 = volume::fluid_ounces::to_kilolitres(123456.0); + assert_approx_eq!(3.50776304, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_teaspoons_1() { + let result: f64 = volume::fluid_ounces::to_teaspoons(123.0); + assert_approx_eq!(590.4, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_teaspoons_2() { + let result: f64 = volume::fluid_ounces::to_teaspoons(9.12); + assert_approx_eq!(43.77598, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_teaspoons_3() { + let result: f64 = volume::fluid_ounces::to_teaspoons(0.2); + assert_approx_eq!(0.96, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_tablespoons_1() { + let result: f64 = volume::fluid_ounces::to_tablespoons(7.0); + assert_approx_eq!(11.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_tablespoons_2() { + let result: f64 = volume::fluid_ounces::to_tablespoons(165.4); + assert_approx_eq!(264.63989, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_tablespoons_3() { + let result: f64 = volume::fluid_ounces::to_tablespoons(80.1); + assert_approx_eq!(128.1599, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_quarts_1() { + let result: f64 = volume::fluid_ounces::to_quarts(89.0); + assert_approx_eq!(2.225, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_quarts_2() { + let result: f64 = volume::fluid_ounces::to_quarts(5.9); + assert_approx_eq!(0.1475, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_quarts_3() { + let result: f64 = volume::fluid_ounces::to_quarts(1300.0); + assert_approx_eq!(32.5, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_pints_1() { + let result: f64 = volume::fluid_ounces::to_pints(1300.0); + assert_approx_eq!(65.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_pints_2() { + let result: f64 = volume::fluid_ounces::to_pints(5.7); + assert_approx_eq!(0.285, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_pints_3() { + let result: f64 = volume::fluid_ounces::to_pints(1900.0); + assert_approx_eq!(95.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_gallons_1() { + let result: f64 = volume::fluid_ounces::to_gallons(1900.0); + assert_approx_eq!(11.875, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_gallons_2() { + let result: f64 = volume::fluid_ounces::to_gallons(5.6); + assert_approx_eq!(0.035, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_gallons_3() { + let result: f64 = volume::fluid_ounces::to_gallons(12345.0); + assert_approx_eq!(77.15625, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_teaspoons_1() { + let result: f64 = volume::fluid_ounces::to_u_s_teaspoons(12345.0); + assert_approx_eq!(71163.512, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_teaspoons_2() { + let result: f64 = volume::fluid_ounces::to_u_s_teaspoons(8.9); + assert_approx_eq!(51.3046, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_teaspoons_3() { + let result: f64 = volume::fluid_ounces::to_u_s_teaspoons(0.005); + assert_approx_eq!(0.028822808, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_tablespoons_1() { + let result: f64 = volume::fluid_ounces::to_u_s_tablespoons(190.0); + assert_approx_eq!(365.089, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_tablespoons_2() { + let result: f64 = volume::fluid_ounces::to_u_s_tablespoons(6.8); + assert_approx_eq!(13.0663, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_tablespoons_3() { + let result: f64 = volume::fluid_ounces::to_u_s_tablespoons(2340.0); + assert_approx_eq!(4496.357, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_quarts_1() { + let result: f64 = volume::fluid_ounces::to_u_s_quarts(45.0); + assert_approx_eq!(1.35107, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_quarts_2() { + let result: f64 = volume::fluid_ounces::to_u_s_quarts(1090.0); + assert_approx_eq!(32.72589, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_quarts_3() { + let result: f64 = volume::fluid_ounces::to_u_s_quarts(777.0); + assert_approx_eq!(23.3285, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_pints_1() { + let result: f64 = volume::fluid_ounces::to_u_s_pints(678.0); + assert_approx_eq!(40.7122, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_pints_2() { + let result: f64 = volume::fluid_ounces::to_u_s_pints(4.5); + assert_approx_eq!(0.270214, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_pints_3() { + let result: f64 = volume::fluid_ounces::to_u_s_pints(1900.0); + assert_approx_eq!(114.0902, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_gallons_1() { + let result: f64 = volume::fluid_ounces::to_u_s_gallons(1890.0); + assert_approx_eq!(14.18622, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_gallons_2() { + let result: f64 = volume::fluid_ounces::to_u_s_gallons(5.8); + assert_approx_eq!(0.0435344, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_gallons_3() { + let result: f64 = volume::fluid_ounces::to_u_s_gallons(10090.0); + assert_approx_eq!(75.734905, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_fluid_ounces_1() { + let result: f64 = volume::fluid_ounces::to_u_s_fluid_ounces(190.0); + assert_approx_eq!(182.544, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_fluid_ounces_2() { + let result: f64 = volume::fluid_ounces::to_u_s_fluid_ounces(54.8); + assert_approx_eq!(52.64964, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_fluid_ounces_3() { + let result: f64 = volume::fluid_ounces::to_u_s_fluid_ounces(1.7); + assert_approx_eq!(1.63329, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_cups_1() { + let result: f64 = volume::fluid_ounces::to_u_s_cups(6.0); + assert_approx_eq!(0.72057, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_cups_2() { + let result: f64 = volume::fluid_ounces::to_u_s_cups(1800.0); + assert_approx_eq!(216.171, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_u_s_cups_3() { + let result: f64 = volume::fluid_ounces::to_u_s_cups(6.9); + assert_approx_eq!(0.828655, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_metres_1() { + let result: f64 = volume::fluid_ounces::to_cubic_metres(316756.0); + assert_approx_eq!(9.00000284, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_metres_2() { + let result: f64 = volume::fluid_ounces::to_cubic_metres(8000.0); + assert_approx_eq!(0.2273043690, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_metres_3() { + let result: f64 = volume::fluid_ounces::to_cubic_metres(123456.0); + assert_approx_eq!(3.5077610, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_feet_1() { + let result: f64 = volume::fluid_ounces::to_cubic_feet(888.0); + assert_approx_eq!(0.891017, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_feet_2() { + let result: f64 = volume::fluid_ounces::to_cubic_feet(100900.0); + assert_approx_eq!(101.242841, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_feet_3() { + let result: f64 = volume::fluid_ounces::to_cubic_feet(678.0); + assert_approx_eq!(0.680304, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_inches_1() { + let result: f64 = volume::fluid_ounces::to_cubic_inches(7.0); + assert_approx_eq!(12.1371, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_inches_2() { + let result: f64 = volume::fluid_ounces::to_cubic_inches(900.0); + assert_approx_eq!(1560.48, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_cubic_inches_3() { + let result: f64 = volume::fluid_ounces::to_cubic_inches(6.0); + assert_approx_eq!(10.4032, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_oil_barrels_1() { + let result: f64 = volume::fluid_ounces::to_oil_barrels(430859.0); + assert_approx_eq!(77.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_oil_barrels_2() { + let result: f64 = volume::fluid_ounces::to_oil_barrels(777.0); + assert_approx_eq!(0.13886, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownfluid_ounces_to_oil_barrels_3() { + let result: f64 = volume::fluid_ounces::to_oil_barrels(1234.0); + assert_approx_eq!(0.2205316, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_millilitres_1() { + let result: f64 = volume::gallons::to_millilitres(1.3); + assert_approx_eq!(5909.92, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_millilitres_2() { + let result: f64 = volume::gallons::to_millilitres(0.45); + assert_approx_eq!(2045.741, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_millilitres_3() { + let result: f64 = volume::gallons::to_millilitres(1.8); + assert_approx_eq!(8182.96, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_litres_1() { + let result: f64 = volume::gallons::to_litres(123.0); + assert_approx_eq!(559.169, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_litres_2() { + let result: f64 = volume::gallons::to_litres(9.3); + assert_approx_eq!(42.2786, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_litres_3() { + let result: f64 = volume::gallons::to_litres(0.67); + assert_approx_eq!(3.04588, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_kilolitres_1() { + let result: f64 = volume::gallons::to_kilolitres(1009.0); + assert_approx_eq!(4.587005, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_kilolitres_2() { + let result: f64 = volume::gallons::to_kilolitres(9.6); + assert_approx_eq!(0.0436425, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_kilolitres_3() { + let result: f64 = volume::gallons::to_kilolitres(123456.0); + assert_approx_eq!(561.242087, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_teaspoons_1() { + let result: f64 = volume::gallons::to_teaspoons(6.0); + assert_approx_eq!(4608.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_teaspoons_2() { + let result: f64 = volume::gallons::to_teaspoons(78.12); + assert_approx_eq!(59996.16, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_teaspoons_3() { + let result: f64 = volume::gallons::to_teaspoons(0.34); + assert_approx_eq!(261.1199, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_tablespoons_1() { + let result: f64 = volume::gallons::to_tablespoons(0.9); + assert_approx_eq!(230.4, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_tablespoons_2() { + let result: f64 = volume::gallons::to_tablespoons(1.6); + assert_approx_eq!(409.6, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_tablespoons_3() { + let result: f64 = volume::gallons::to_tablespoons(0.33); + assert_approx_eq!(84.47997, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_quarts_1() { + let result: f64 = volume::gallons::to_quarts(109.0); + assert_approx_eq!(436.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_quarts_2() { + let result: f64 = volume::gallons::to_quarts(5.8); + assert_approx_eq!(23.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_quarts_3() { + let result: f64 = volume::gallons::to_quarts(0.23); + assert_approx_eq!(0.92, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_pints_1() { + let result: f64 = volume::gallons::to_pints(0.23); + assert_approx_eq!(1.84, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_pints_2() { + let result: f64 = volume::gallons::to_pints(190.0); + assert_approx_eq!(1520.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_pints_3() { + let result: f64 = volume::gallons::to_pints(24.7); + assert_approx_eq!(197.6, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_fluid_ounces_1() { + let result: f64 = volume::gallons::to_fluid_ounces(24.7); + assert_approx_eq!(3952.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_fluid_ounces_2() { + let result: f64 = volume::gallons::to_fluid_ounces(13.09); + assert_approx_eq!(2094.4, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_fluid_ounces_3() { + let result: f64 = volume::gallons::to_fluid_ounces(5.8); + assert_approx_eq!(928.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_teaspoons_1() { + let result: f64 = volume::gallons::to_u_s_teaspoons(5.8); + assert_approx_eq!(5349.51, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_teaspoons_2() { + let result: f64 = volume::gallons::to_u_s_teaspoons(0.44); + assert_approx_eq!(405.8251, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_teaspoons_3() { + let result: f64 = volume::gallons::to_u_s_teaspoons(1.9); + assert_approx_eq!(1752.43, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_tablespoons_1() { + let result: f64 = volume::gallons::to_u_s_tablespoons(1.8); + assert_approx_eq!(553.398, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_tablespoons_2() { + let result: f64 = volume::gallons::to_u_s_tablespoons(0.33); + assert_approx_eq!(101.4562, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_tablespoons_3() { + let result: f64 = volume::gallons::to_u_s_tablespoons(100.0); + assert_approx_eq!(30744.33080, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_quarts_1() { + let result: f64 = volume::gallons::to_u_s_quarts(78.0); + assert_approx_eq!(374.696, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_quarts_2() { + let result: f64 = volume::gallons::to_u_s_quarts(1.7); + assert_approx_eq!(8.16646, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_quarts_3() { + let result: f64 = volume::gallons::to_u_s_quarts(16.9); + assert_approx_eq!(81.18421, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_pints_1() { + let result: f64 = volume::gallons::to_u_s_pints(13.4); + assert_approx_eq!(128.7418, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_pints_2() { + let result: f64 = volume::gallons::to_u_s_pints(8.12); + assert_approx_eq!(78.01371, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_pints_3() { + let result: f64 = volume::gallons::to_u_s_pints(0.99); + assert_approx_eq!(9.511523, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_gallons_1() { + let result: f64 = volume::gallons::to_u_s_gallons(1.5); + assert_approx_eq!(1.80142, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_gallons_2() { + let result: f64 = volume::gallons::to_u_s_gallons(0.78); + assert_approx_eq!(0.9367409, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_gallons_3() { + let result: f64 = volume::gallons::to_u_s_gallons(103.0); + assert_approx_eq!(123.698, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_fluid_ounces_1() { + let result: f64 = volume::gallons::to_u_s_fluid_ounces(111.0); + assert_approx_eq!(17063.1, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_fluid_ounces_2() { + let result: f64 = volume::gallons::to_u_s_fluid_ounces(89.9); + assert_approx_eq!(13819.57, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_fluid_ounces_3() { + let result: f64 = volume::gallons::to_u_s_fluid_ounces(1.2); + assert_approx_eq!(184.466, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_cups_1() { + let result: f64 = volume::gallons::to_u_s_cups(1.2); + assert_approx_eq!(23.0582, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_cups_2() { + let result: f64 = volume::gallons::to_u_s_cups(0.55); + assert_approx_eq!(10.56836, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_u_s_cups_3() { + let result: f64 = volume::gallons::to_u_s_cups(890.0); + assert_approx_eq!(17101.534007630, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_metres_1() { + let result: f64 = volume::gallons::to_cubic_metres(9898.62); + assert_approx_eq!(45.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_metres_2() { + let result: f64 = volume::gallons::to_cubic_metres(12345.0); + assert_approx_eq!(56.121481, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_metres_3() { + let result: f64 = volume::gallons::to_cubic_metres(80.0); + assert_approx_eq!(0.363687, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_feet_1() { + let result: f64 = volume::gallons::to_cubic_feet(55.0); + assert_approx_eq!(8.8299, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_feet_2() { + let result: f64 = volume::gallons::to_cubic_feet(90.5); + assert_approx_eq!(14.5292, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_feet_3() { + let result: f64 = volume::gallons::to_cubic_feet(123.0); + assert_approx_eq!(19.7469, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_inches_1() { + let result: f64 = volume::gallons::to_cubic_inches(66.0); + assert_approx_eq!(18309.6539, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_inches_2() { + let result: f64 = volume::gallons::to_cubic_inches(2.4007); + assert_approx_eq!(666.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_cubic_inches_3() { + let result: f64 = volume::gallons::to_cubic_inches(77.0); + assert_approx_eq!(21361.2629, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_oil_barrels_1() { + let result: f64 = volume::gallons::to_oil_barrels(174.862); + assert_approx_eq!(5.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_oil_barrels_2() { + let result: f64 = volume::gallons::to_oil_barrels(19409.6); + assert_approx_eq!(555.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowngallons_to_oil_barrels_3() { + let result: f64 = volume::gallons::to_oil_barrels(24.4806); + assert_approx_eq!(0.7, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_millilitres_1() { + let result: f64 = volume::kilolitres::to_millilitres(0.09); + assert_approx_eq!(90000.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_millilitres_2() { + let result: f64 = volume::kilolitres::to_millilitres(0.00123); + assert_approx_eq!(1230.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_millilitres_3() { + let result: f64 = volume::kilolitres::to_millilitres(1.2); + assert_approx_eq!(1.2e+6, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_litres_1() { + let result: f64 = volume::kilolitres::to_litres(1.2); + assert_approx_eq!(1200.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_litres_2() { + let result: f64 = volume::kilolitres::to_litres(0.8); + assert_approx_eq!(800.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_litres_3() { + let result: f64 = volume::kilolitres::to_litres(456.0); + assert_approx_eq!(456000.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_teaspoons_1() { + let result: f64 = volume::kilolitres::to_teaspoons(0.7); + assert_approx_eq!(118255.41900799, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_teaspoons_2() { + let result: f64 = volume::kilolitres::to_teaspoons(0.01); + assert_approx_eq!(1689.363, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_teaspoons_3() { + let result: f64 = volume::kilolitres::to_teaspoons(4.5); + assert_approx_eq!(760213.407908, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_tablespoons_1() { + let result: f64 = volume::kilolitres::to_tablespoons(0.3); + assert_approx_eq!(16893.631286856, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_tablespoons_2() { + let result: f64 = volume::kilolitres::to_tablespoons(2.9); + assert_approx_eq!(163305.10243961, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_tablespoons_3() { + let result: f64 = volume::kilolitres::to_tablespoons(0.067); + assert_approx_eq!(3772.911, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_quarts_1() { + let result: f64 = volume::kilolitres::to_quarts(0.09); + assert_approx_eq!(79.18893, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_quarts_2() { + let result: f64 = volume::kilolitres::to_quarts(2.3); + assert_approx_eq!(2023.72, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_quarts_3() { + let result: f64 = volume::kilolitres::to_quarts(0.67); + assert_approx_eq!(589.5176, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_pints_1() { + let result: f64 = volume::kilolitres::to_pints(0.4); + assert_approx_eq!(703.902, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_pints_2() { + let result: f64 = volume::kilolitres::to_pints(67.0); + assert_approx_eq!(117903.46835618, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_pints_3() { + let result: f64 = volume::kilolitres::to_pints(9.3); + assert_approx_eq!(16365.7, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_gallons_1() { + let result: f64 = volume::kilolitres::to_gallons(109.0); + assert_approx_eq!(23976.638149, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_gallons_2() { + let result: f64 = volume::kilolitres::to_gallons(7.2); + assert_approx_eq!(1583.78, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_gallons_3() { + let result: f64 = volume::kilolitres::to_gallons(0.4); + assert_approx_eq!(87.9877, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_fluid_ounces_1() { + let result: f64 = volume::kilolitres::to_fluid_ounces(0.2); + assert_approx_eq!(7039.02, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_fluid_ounces_2() { + let result: f64 = volume::kilolitres::to_fluid_ounces(4.8); + assert_approx_eq!(168936.31286856, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_fluid_ounces_3() { + let result: f64 = volume::kilolitres::to_fluid_ounces(6.0); + assert_approx_eq!(211170.391085, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_teaspoons_1() { + let result: f64 = volume::kilolitres::to_u_s_teaspoons(4.0); + assert_approx_eq!(811536.5448442, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_teaspoons_2() { + let result: f64 = volume::kilolitres::to_u_s_teaspoons(0.2); + assert_approx_eq!(40576.82724221160, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_teaspoons_3() { + let result: f64 = volume::kilolitres::to_u_s_teaspoons(2.4); + assert_approx_eq!(486921.92690653, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_tablespoons_1() { + let result: f64 = volume::kilolitres::to_u_s_tablespoons(1.3); + assert_approx_eq!(87916.45902479, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_tablespoons_2() { + let result: f64 = volume::kilolitres::to_u_s_tablespoons(0.6); + assert_approx_eq!(40576.82724221, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_tablespoons_3() { + let result: f64 = volume::kilolitres::to_u_s_tablespoons(0.03); + assert_approx_eq!(2028.841, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_quarts_1() { + let result: f64 = volume::kilolitres::to_u_s_quarts(0.09); + assert_approx_eq!(95.10194, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_quarts_2() { + let result: f64 = volume::kilolitres::to_u_s_quarts(2.5); + assert_approx_eq!(2641.72, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_quarts_3() { + let result: f64 = volume::kilolitres::to_u_s_quarts(178.9); + assert_approx_eq!(189041.52, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_pints_1() { + let result: f64 = volume::kilolitres::to_u_s_pints(67.0); + assert_approx_eq!(141596.2200639, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_pints_2() { + let result: f64 = volume::kilolitres::to_u_s_pints(4.7); + assert_approx_eq!(9932.87, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_pints_3() { + let result: f64 = volume::kilolitres::to_u_s_pints(108.9); + assert_approx_eq!(230146.69, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_gallons_1() { + let result: f64 = volume::kilolitres::to_u_s_gallons(1.6); + assert_approx_eq!(422.675, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_gallons_2() { + let result: f64 = volume::kilolitres::to_u_s_gallons(57.0); + assert_approx_eq!(15057.8, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_gallons_3() { + let result: f64 = volume::kilolitres::to_u_s_gallons(0.88); + assert_approx_eq!(232.4714, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_fluid_ounces_1() { + let result: f64 = volume::kilolitres::to_u_s_fluid_ounces(0.07); + assert_approx_eq!(2366.982, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_fluid_ounces_2() { + let result: f64 = volume::kilolitres::to_u_s_fluid_ounces(4.2); + assert_approx_eq!(142018.89516765, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_fluid_ounces_3() { + let result: f64 = volume::kilolitres::to_u_s_fluid_ounces(12.0); + assert_approx_eq!(405768.27190759, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_cups_1() { + let result: f64 = volume::kilolitres::to_u_s_cups(12.0); + assert_approx_eq!(50721.03405276, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_cups_2() { + let result: f64 = volume::kilolitres::to_u_s_cups(0.8); + assert_approx_eq!(3381.4, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_u_s_cups_3() { + let result: f64 = volume::kilolitres::to_u_s_cups(6.2); + assert_approx_eq!(26205.86759392, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_metres_1() { + let result: f64 = volume::kilolitres::to_cubic_metres(1000.0); + assert_approx_eq!(1000.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_metres_2() { + let result: f64 = volume::kilolitres::to_cubic_metres(0.9); + assert_approx_eq!(0.9, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_metres_3() { + let result: f64 = volume::kilolitres::to_cubic_metres(6.09); + assert_approx_eq!(6.09, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_feet_1() { + let result: f64 = volume::kilolitres::to_cubic_feet(0.0566337); + assert_approx_eq!(2.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_feet_2() { + let result: f64 = volume::kilolitres::to_cubic_feet(7.9); + assert_approx_eq!(278.986, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_feet_3() { + let result: f64 = volume::kilolitres::to_cubic_feet(88.0); + assert_approx_eq!(3107.69, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_inches_1() { + let result: f64 = volume::kilolitres::to_cubic_inches(6.0); + assert_approx_eq!(366142.19999, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_inches_2() { + let result: f64 = volume::kilolitres::to_cubic_inches(0.1); + assert_approx_eq!(6102.37, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_cubic_inches_3() { + let result: f64 = volume::kilolitres::to_cubic_inches(0.8); + assert_approx_eq!(48818.959, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_oil_barrels_1() { + let result: f64 = volume::kilolitres::to_oil_barrels(0.476962); + assert_approx_eq!(3.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_oil_barrels_2() { + let result: f64 = volume::kilolitres::to_oil_barrels(4.0); + assert_approx_eq!(25.1592, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownkilolitres_to_oil_barrels_3() { + let result: f64 = volume::kilolitres::to_oil_barrels(6.0); + assert_approx_eq!(37.7389, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_millilitres_1() { + let result: f64 = volume::litres::to_millilitres(34.0); + assert_approx_eq!(34000.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_millilitres_2() { + let result: f64 = volume::litres::to_millilitres(0.67); + assert_approx_eq!(670.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_millilitres_3() { + let result: f64 = volume::litres::to_millilitres(1.09); + assert_approx_eq!(1090.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_kilolitres_1() { + let result: f64 = volume::litres::to_kilolitres(200.0); + assert_approx_eq!(0.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_kilolitres_2() { + let result: f64 = volume::litres::to_kilolitres(12345.0); + assert_approx_eq!(12.345, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_kilolitres_3() { + let result: f64 = volume::litres::to_kilolitres(80.0); + assert_approx_eq!(0.08, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_teaspoons_1() { + let result: f64 = volume::litres::to_teaspoons(3.0); + assert_approx_eq!(506.809, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_teaspoons_2() { + let result: f64 = volume::litres::to_teaspoons(0.2); + assert_approx_eq!(33.7873, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_teaspoons_3() { + let result: f64 = volume::litres::to_teaspoons(4.2); + assert_approx_eq!(709.533, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_tablespoons_1() { + let result: f64 = volume::litres::to_tablespoons(3.0); + assert_approx_eq!(168.936, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_tablespoons_2() { + let result: f64 = volume::litres::to_tablespoons(0.4); + assert_approx_eq!(22.5248, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_tablespoons_3() { + let result: f64 = volume::litres::to_tablespoons(67.0); + assert_approx_eq!(3772.91, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_quarts_1() { + let result: f64 = volume::litres::to_quarts(54.0); + assert_approx_eq!(47.5134, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_quarts_2() { + let result: f64 = volume::litres::to_quarts(2.0); + assert_approx_eq!(1.75975, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_quarts_3() { + let result: f64 = volume::litres::to_quarts(0.7); + assert_approx_eq!(0.615914, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_pints_1() { + let result: f64 = volume::litres::to_pints(0.5); + assert_approx_eq!(0.879877, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_pints_2() { + let result: f64 = volume::litres::to_pints(145.0); + assert_approx_eq!(255.164, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_pints_3() { + let result: f64 = volume::litres::to_pints(9.1); + assert_approx_eq!(16.0138, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_gallons_1() { + let result: f64 = volume::litres::to_gallons(12.9); + assert_approx_eq!(2.837603, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_gallons_2() { + let result: f64 = volume::litres::to_gallons(109.0); + assert_approx_eq!(23.9766, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_gallons_3() { + let result: f64 = volume::litres::to_gallons(67.0); + assert_approx_eq!(14.7379, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_fluid_ounces_1() { + let result: f64 = volume::litres::to_fluid_ounces(5.0); + assert_approx_eq!(175.975, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_fluid_ounces_2() { + let result: f64 = volume::litres::to_fluid_ounces(0.3); + assert_approx_eq!(10.5585, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_fluid_ounces_3() { + let result: f64 = volume::litres::to_fluid_ounces(1.1); + assert_approx_eq!(38.7146, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_teaspoons_1() { + let result: f64 = volume::litres::to_u_s_teaspoons(12.0); + assert_approx_eq!(2434.61, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_teaspoons_2() { + let result: f64 = volume::litres::to_u_s_teaspoons(0.7); + assert_approx_eq!(142.019, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_teaspoons_3() { + let result: f64 = volume::litres::to_u_s_teaspoons(89.9); + assert_approx_eq!(18239.29, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_tablespoons_1() { + let result: f64 = volume::litres::to_u_s_tablespoons(12.0); + assert_approx_eq!(811.537, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_tablespoons_2() { + let result: f64 = volume::litres::to_u_s_tablespoons(5.6); + assert_approx_eq!(378.717, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_tablespoons_3() { + let result: f64 = volume::litres::to_u_s_tablespoons(0.5); + assert_approx_eq!(33.814, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_quarts_1() { + let result: f64 = volume::litres::to_u_s_quarts(12.0); + assert_approx_eq!(12.6803, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_quarts_2() { + let result: f64 = volume::litres::to_u_s_quarts(1.09); + assert_approx_eq!(1.15179, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_quarts_3() { + let result: f64 = volume::litres::to_u_s_quarts(5.5); + assert_approx_eq!(5.81179, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_pints_1() { + let result: f64 = volume::litres::to_u_s_pints(3.4); + assert_approx_eq!(7.18548, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_pints_2() { + let result: f64 = volume::litres::to_u_s_pints(0.8); + assert_approx_eq!(1.6907, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_pints_3() { + let result: f64 = volume::litres::to_u_s_pints(3000.0); + assert_approx_eq!(6340.129, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_gallons_1() { + let result: f64 = volume::litres::to_u_s_gallons(109.1); + assert_approx_eq!(28.821171, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_gallons_2() { + let result: f64 = volume::litres::to_u_s_gallons(41.5); + assert_approx_eq!(10.96314, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_gallons_3() { + let result: f64 = volume::litres::to_u_s_gallons(0.8); + assert_approx_eq!(0.211338, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_fluid_ounces_1() { + let result: f64 = volume::litres::to_u_s_fluid_ounces(81.0); + assert_approx_eq!(2738.94, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_fluid_ounces_2() { + let result: f64 = volume::litres::to_u_s_fluid_ounces(7.3); + assert_approx_eq!(246.842, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_fluid_ounces_3() { + let result: f64 = volume::litres::to_u_s_fluid_ounces(0.65); + assert_approx_eq!(21.97911, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_cups_1() { + let result: f64 = volume::litres::to_u_s_cups(0.9); + assert_approx_eq!(3.80408, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_cups_2() { + let result: f64 = volume::litres::to_u_s_cups(103.9); + assert_approx_eq!(439.15962, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_u_s_cups_3() { + let result: f64 = volume::litres::to_u_s_cups(71.6); + assert_approx_eq!(302.6355, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_metres_1() { + let result: f64 = volume::litres::to_cubic_metres(400.5); + assert_approx_eq!(0.4005, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_metres_2() { + let result: f64 = volume::litres::to_cubic_metres(900.0); + assert_approx_eq!(0.9, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_metres_3() { + let result: f64 = volume::litres::to_cubic_metres(6090.0); + assert_approx_eq!(6.09, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_feet_1() { + let result: f64 = volume::litres::to_cubic_feet(5.0); + assert_approx_eq!(0.176573, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_feet_2() { + let result: f64 = volume::litres::to_cubic_feet(84.9505); + assert_approx_eq!(3.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_feet_3() { + let result: f64 = volume::litres::to_cubic_feet(6.0); + assert_approx_eq!(0.211888, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_inches_1() { + let result: f64 = volume::litres::to_cubic_inches(666.0); + assert_approx_eq!(40641.7842, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_inches_2() { + let result: f64 = volume::litres::to_cubic_inches(788.0); + assert_approx_eq!(48086.675599, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_cubic_inches_3() { + let result: f64 = volume::litres::to_cubic_inches(4.0); + assert_approx_eq!(244.095, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_oil_barrels_1() { + let result: f64 = volume::litres::to_oil_barrels(8744.3); + assert_approx_eq!(55.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_oil_barrels_2() { + let result: f64 = volume::litres::to_oil_barrels(1234.0); + assert_approx_eq!(7.761626, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownlitres_to_oil_barrels_3() { + let result: f64 = volume::litres::to_oil_barrels(953.924); + assert_approx_eq!(6.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_litres_1() { + let result: f64 = volume::millilitres::to_litres(1900.0); + assert_approx_eq!(1.9, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_litres_2() { + let result: f64 = volume::millilitres::to_litres(56789.0); + assert_approx_eq!(56.789, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_litres_3() { + let result: f64 = volume::millilitres::to_litres(567.0); + assert_approx_eq!(0.567, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_kilolitres_1() { + let result: f64 = volume::millilitres::to_kilolitres(10060000.0); + assert_approx_eq!(10.06, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_kilolitres_2() { + let result: f64 = volume::millilitres::to_kilolitres(987654.0); + assert_approx_eq!(0.987654, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_kilolitres_3() { + let result: f64 = volume::millilitres::to_kilolitres(405000.0); + assert_approx_eq!(0.405, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_teaspoons_1() { + let result: f64 = volume::millilitres::to_teaspoons(1.0); + assert_approx_eq!(0.168936, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_teaspoons_2() { + let result: f64 = volume::millilitres::to_teaspoons(56.0); + assert_approx_eq!(9.46043, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_teaspoons_3() { + let result: f64 = volume::millilitres::to_teaspoons(12.3); + assert_approx_eq!(2.077917, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_tablespoons_1() { + let result: f64 = volume::millilitres::to_tablespoons(109.0); + assert_approx_eq!(6.13802, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_tablespoons_2() { + let result: f64 = volume::millilitres::to_tablespoons(88.0); + assert_approx_eq!(4.95547, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_tablespoons_3() { + let result: f64 = volume::millilitres::to_tablespoons(12.0); + assert_approx_eq!(0.675745, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_quarts_1() { + let result: f64 = volume::millilitres::to_quarts(890.0); + assert_approx_eq!(0.783091, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_quarts_2() { + let result: f64 = volume::millilitres::to_quarts(12345.0); + assert_approx_eq!(10.862081, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_quarts_3() { + let result: f64 = volume::millilitres::to_quarts(129.0); + assert_approx_eq!(0.113504, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_pints_1() { + let result: f64 = volume::millilitres::to_pints(124.0); + assert_approx_eq!(0.218209, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_pints_2() { + let result: f64 = volume::millilitres::to_pints(99.0); + assert_approx_eq!(0.174216, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_pints_3() { + let result: f64 = volume::millilitres::to_pints(607.3); + assert_approx_eq!(1.0686986, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_gallons_1() { + let result: f64 = volume::millilitres::to_gallons(1234.0); + assert_approx_eq!(0.2714421, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_gallons_2() { + let result: f64 = volume::millilitres::to_gallons(9000.0); + assert_approx_eq!(1.979723, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_gallons_3() { + let result: f64 = volume::millilitres::to_gallons(10209.98); + assert_approx_eq!(2.2458816257, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_fluid_ounces_1() { + let result: f64 = volume::millilitres::to_fluid_ounces(78.0); + assert_approx_eq!(2.74522, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_fluid_ounces_2() { + let result: f64 = volume::millilitres::to_fluid_ounces(12.9); + assert_approx_eq!(0.4540165, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_fluid_ounces_3() { + let result: f64 = volume::millilitres::to_fluid_ounces(1009.0); + assert_approx_eq!(35.51184, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_teaspoons_1() { + let result: f64 = volume::millilitres::to_u_s_teaspoons(100.0); + assert_approx_eq!(20.2884, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_teaspoons_2() { + let result: f64 = volume::millilitres::to_u_s_teaspoons(12.3); + assert_approx_eq!(2.495476, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_teaspoons_3() { + let result: f64 = volume::millilitres::to_u_s_teaspoons(69.0); + assert_approx_eq!(13.999, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_tablespoons_1() { + let result: f64 = volume::millilitres::to_u_s_tablespoons(38.0); + assert_approx_eq!(2.56987, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_tablespoons_2() { + let result: f64 = volume::millilitres::to_u_s_tablespoons(1023.0); + assert_approx_eq!(69.18349, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_tablespoons_3() { + let result: f64 = volume::millilitres::to_u_s_tablespoons(88.8); + assert_approx_eq!(6.00537, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_quarts_1() { + let result: f64 = volume::millilitres::to_u_s_quarts(1009.0); + assert_approx_eq!(1.066198, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_quarts_2() { + let result: f64 = volume::millilitres::to_u_s_quarts(4567.0); + assert_approx_eq!(4.825895, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_quarts_3() { + let result: f64 = volume::millilitres::to_u_s_quarts(8009.0); + assert_approx_eq!(8.463016, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_pints_1() { + let result: f64 = volume::millilitres::to_u_s_pints(110.0); + assert_approx_eq!(0.232471, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_pints_2() { + let result: f64 = volume::millilitres::to_u_s_pints(2032.0); + assert_approx_eq!(4.294381, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_pints_3() { + let result: f64 = volume::millilitres::to_u_s_pints(1000.9); + assert_approx_eq!(2.11527846, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_gallons_1() { + let result: f64 = volume::millilitres::to_u_s_gallons(5000.0); + assert_approx_eq!(1.32086, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_gallons_2() { + let result: f64 = volume::millilitres::to_u_s_gallons(123456.0); + assert_approx_eq!(32.6136249, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_gallons_3() { + let result: f64 = volume::millilitres::to_u_s_gallons(900.0); + assert_approx_eq!(0.237755, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_fluid_ounces_1() { + let result: f64 = volume::millilitres::to_u_s_fluid_ounces(67.0); + assert_approx_eq!(2.26554, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_fluid_ounces_2() { + let result: f64 = volume::millilitres::to_u_s_fluid_ounces(12.6); + assert_approx_eq!(0.4260567, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_fluid_ounces_3() { + let result: f64 = volume::millilitres::to_u_s_fluid_ounces(11009.0); + assert_approx_eq!(372.25858, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_cups_1() { + let result: f64 = volume::millilitres::to_u_s_cups(348.0); + assert_approx_eq!(1.47091, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_cups_2() { + let result: f64 = volume::millilitres::to_u_s_cups(12.9); + assert_approx_eq!(0.05452511, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_u_s_cups_3() { + let result: f64 = volume::millilitres::to_u_s_cups(700.0); + assert_approx_eq!(2.95873, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownmillilitres_to_cubic_metres_1() { + let result: f64 = volume::millilitres::to_cubic_metres(9999999.0); + assert_approx_eq!(9.999999, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_fluid_ounces_2() { - let result: f64 = volume::litres::to_fluid_ounces(0.3); - assert_approx_eq!(10.5585, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_metres_2() { + let result: f64 = volume::millilitres::to_cubic_metres(123456.0); + assert_approx_eq!(0.123456, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_fluid_ounces_3() { - let result: f64 = volume::litres::to_fluid_ounces(1.1); - assert_approx_eq!(38.7146, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_metres_3() { + let result: f64 = volume::millilitres::to_cubic_metres(400500.0); + assert_approx_eq!(0.4005, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_teaspoons_1() { - let result: f64 = volume::litres::to_u_s_teaspoons(12.0); - assert_approx_eq!(2434.61, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_feet_1() { + let result: f64 = volume::millilitres::to_cubic_feet(254852.0); + assert_approx_eq!(9.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_teaspoons_2() { - let result: f64 = volume::litres::to_u_s_teaspoons(0.7); - assert_approx_eq!(142.019, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_feet_2() { + let result: f64 = volume::millilitres::to_cubic_feet(6000.0); + assert_approx_eq!(0.211888, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_teaspoons_3() { - let result: f64 = volume::litres::to_u_s_teaspoons(89.9); - assert_approx_eq!(18239.29, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_feet_3() { + let result: f64 = volume::millilitres::to_cubic_feet(70792.1); + assert_approx_eq!(2.5, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_tablespoons_1() { - let result: f64 = volume::litres::to_u_s_tablespoons(12.0); - assert_approx_eq!(811.537, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_inches_1() { + let result: f64 = volume::millilitres::to_cubic_inches(777.0); + assert_approx_eq!(47.4154, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_tablespoons_2() { - let result: f64 = volume::litres::to_u_s_tablespoons(5.6); - assert_approx_eq!(378.717, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_inches_2() { + let result: f64 = volume::millilitres::to_cubic_inches(98.3224); + assert_approx_eq!(5.999987, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_tablespoons_3() { - let result: f64 = volume::litres::to_u_s_tablespoons(0.5); - assert_approx_eq!(33.814, result, 0.01); + fn it_convert_knownmillilitres_to_cubic_inches_3() { + let result: f64 = volume::millilitres::to_cubic_inches(12.0); + assert_approx_eq!(0.732285, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_quarts_1() { - let result: f64 = volume::litres::to_u_s_quarts(12.0); - assert_approx_eq!(12.6803, result, 0.01); + fn it_convert_knownmillilitres_to_oil_barrels_1() { + let result: f64 = volume::millilitres::to_oil_barrels(47696.2); + assert_approx_eq!(0.3, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_quarts_2() { - let result: f64 = volume::litres::to_u_s_quarts(1.09); - assert_approx_eq!(1.15179, result, 0.01); + fn it_convert_knownmillilitres_to_oil_barrels_2() { + let result: f64 = volume::millilitres::to_oil_barrels(143089.0); + assert_approx_eq!(0.9, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_quarts_3() { - let result: f64 = volume::litres::to_u_s_quarts(5.5); - assert_approx_eq!(5.81179, result, 0.01); + fn it_convert_knownmillilitres_to_oil_barrels_3() { + let result: f64 = volume::millilitres::to_oil_barrels(317.97459); + assert_approx_eq!(0.002, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_pints_1() { - let result: f64 = volume::litres::to_u_s_pints(3.4); - assert_approx_eq!(7.18548, result, 0.01); + fn it_convert_knownoil_barrels_to_millilitres_1() { + let result: f64 = volume::oil_barrels::to_millilitres(0.8); + assert_approx_eq!(127189.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_pints_2() { - let result: f64 = volume::litres::to_u_s_pints(0.8); - assert_approx_eq!(1.6907, result, 0.01); + fn it_convert_knownoil_barrels_to_millilitres_2() { + let result: f64 = volume::oil_barrels::to_millilitres(6.0); + assert_approx_eq!(953922.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_pints_3() { - let result: f64 = volume::litres::to_u_s_pints(3000.0); - assert_approx_eq!(6340.129, result, 0.01); + fn it_convert_knownoil_barrels_to_millilitres_3() { + let result: f64 = volume::oil_barrels::to_millilitres(0.06289182); + assert_approx_eq!(9998.981786, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_gallons_1() { - let result: f64 = volume::litres::to_u_s_gallons(109.1); - assert_approx_eq!(28.821171, result, 0.01); + fn it_convert_knownoil_barrels_to_litres_1() { + let result: f64 = volume::oil_barrels::to_litres(12.0); + assert_approx_eq!(1907.85, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_gallons_2() { - let result: f64 = volume::litres::to_u_s_gallons(41.5); - assert_approx_eq!(10.96314, result, 0.01); + fn it_convert_knownoil_barrels_to_litres_2() { + let result: f64 = volume::oil_barrels::to_litres(6.0); + assert_approx_eq!(953.924, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_gallons_3() { - let result: f64 = volume::litres::to_u_s_gallons(0.8); - assert_approx_eq!(0.211338, result, 0.01); + fn it_convert_knownoil_barrels_to_litres_3() { + let result: f64 = volume::oil_barrels::to_litres(77.0); + assert_approx_eq!(12242.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_fluid_ounces_1() { - let result: f64 = volume::litres::to_u_s_fluid_ounces(81.0); - assert_approx_eq!(2738.94, result, 0.01); + fn it_convert_knownoil_barrels_to_kilolitres_1() { + let result: f64 = volume::oil_barrels::to_kilolitres(12.0); + assert_approx_eq!(1.90785, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_fluid_ounces_2() { - let result: f64 = volume::litres::to_u_s_fluid_ounces(7.3); - assert_approx_eq!(246.842, result, 0.01); + fn it_convert_knownoil_barrels_to_kilolitres_2() { + let result: f64 = volume::oil_barrels::to_kilolitres(8.0); + assert_approx_eq!(1.2719, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_fluid_ounces_3() { - let result: f64 = volume::litres::to_u_s_fluid_ounces(0.65); - assert_approx_eq!(21.97911, result, 0.01); + fn it_convert_knownoil_barrels_to_kilolitres_3() { + let result: f64 = volume::oil_barrels::to_kilolitres(77.0); + assert_approx_eq!(12.242, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_cups_1() { - let result: f64 = volume::litres::to_u_s_cups(0.9); - assert_approx_eq!(3.80408, result, 0.01); + fn it_convert_knownoil_barrels_to_teaspoons_1() { + let result: f64 = volume::oil_barrels::to_teaspoons(0.6); + assert_approx_eq!(16115.219, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_cups_2() { - let result: f64 = volume::litres::to_u_s_cups(103.9); - assert_approx_eq!(439.15962, result, 0.01); + fn it_convert_knownoil_barrels_to_teaspoons_2() { + let result: f64 = volume::oil_barrels::to_teaspoons(4.0); + assert_approx_eq!(107434.8, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownlitres_to_u_s_cups_3() { - let result: f64 = volume::litres::to_u_s_cups(71.6); - assert_approx_eq!(302.6355, result, 0.01); + fn it_convert_knownoil_barrels_to_teaspoons_3() { + let result: f64 = volume::oil_barrels::to_teaspoons(6.7); + assert_approx_eq!(179953.29, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_litres_1() { - let result: f64 = volume::millilitres::to_litres(1900.0); - assert_approx_eq!(1.9, result, 0.01); + fn it_convert_knownoil_barrels_to_tablespoons_1() { + let result: f64 = volume::oil_barrels::to_tablespoons(0.7); + assert_approx_eq!(6267.04, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_litres_2() { - let result: f64 = volume::millilitres::to_litres(56789.0); - assert_approx_eq!(56.789, result, 0.01); + fn it_convert_knownoil_barrels_to_tablespoons_2() { + let result: f64 = volume::oil_barrels::to_tablespoons(8.0); + assert_approx_eq!(71623.279, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_litres_3() { - let result: f64 = volume::millilitres::to_litres(567.0); - assert_approx_eq!(0.567, result, 0.01); + fn it_convert_knownoil_barrels_to_tablespoons_3() { + let result: f64 = volume::oil_barrels::to_tablespoons(10.052487); + assert_approx_eq!(89999.011387, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_kilolitres_1() { - let result: f64 = volume::millilitres::to_kilolitres(10060000.0); - assert_approx_eq!(10.06, result, 0.01); + fn it_convert_knownoil_barrels_to_quarts_1() { + let result: f64 = volume::oil_barrels::to_quarts(88.0); + assert_approx_eq!(12310.232, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_kilolitres_2() { - let result: f64 = volume::millilitres::to_kilolitres(987654.0); - assert_approx_eq!(0.987654, result, 0.01); + fn it_convert_knownoil_barrels_to_quarts_2() { + let result: f64 = volume::oil_barrels::to_quarts(12.0); + assert_approx_eq!(1678.67, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_kilolitres_3() { - let result: f64 = volume::millilitres::to_kilolitres(405000.0); - assert_approx_eq!(0.405, result, 0.01); + fn it_convert_knownoil_barrels_to_quarts_3() { + let result: f64 = volume::oil_barrels::to_quarts(6.0); + assert_approx_eq!(839.336, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_teaspoons_1() { - let result: f64 = volume::millilitres::to_teaspoons(1.0); - assert_approx_eq!(0.168936, result, 0.01); + fn it_convert_knownoil_barrels_to_pints_1() { + let result: f64 = volume::oil_barrels::to_pints(8.0); + assert_approx_eq!(2238.23, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_teaspoons_2() { - let result: f64 = volume::millilitres::to_teaspoons(56.0); - assert_approx_eq!(9.46043, result, 0.01); + fn it_convert_knownoil_barrels_to_pints_2() { + let result: f64 = volume::oil_barrels::to_pints(6.0); + assert_approx_eq!(1678.67, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_teaspoons_3() { - let result: f64 = volume::millilitres::to_teaspoons(12.3); - assert_approx_eq!(2.077917, result, 0.01); + fn it_convert_knownoil_barrels_to_pints_3() { + let result: f64 = volume::oil_barrels::to_pints(0.275218); + assert_approx_eq!(77.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_tablespoons_1() { - let result: f64 = volume::millilitres::to_tablespoons(109.0); - assert_approx_eq!(6.13802, result, 0.01); + fn it_convert_knownoil_barrels_to_gallons_1() { + let result: f64 = volume::oil_barrels::to_gallons(4.0); + assert_approx_eq!(139.889, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_tablespoons_2() { - let result: f64 = volume::millilitres::to_tablespoons(88.0); - assert_approx_eq!(4.95547, result, 0.01); + fn it_convert_knownoil_barrels_to_gallons_2() { + let result: f64 = volume::oil_barrels::to_gallons(6.0); + assert_approx_eq!(209.834, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_tablespoons_3() { - let result: f64 = volume::millilitres::to_tablespoons(12.0); - assert_approx_eq!(0.675745, result, 0.01); + fn it_convert_knownoil_barrels_to_gallons_3() { + let result: f64 = volume::oil_barrels::to_gallons(18.0); + assert_approx_eq!(629.502, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_quarts_1() { - let result: f64 = volume::millilitres::to_quarts(890.0); - assert_approx_eq!(0.783091, result, 0.01); + fn it_convert_knownoil_barrels_to_fluid_ounces_1() { + let result: f64 = volume::oil_barrels::to_fluid_ounces(0.5); + assert_approx_eq!(2797.79, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_quarts_2() { - let result: f64 = volume::millilitres::to_quarts(12345.0); - assert_approx_eq!(10.862081, result, 0.01); + fn it_convert_knownoil_barrels_to_fluid_ounces_2() { + let result: f64 = volume::oil_barrels::to_fluid_ounces(6.0); + assert_approx_eq!(33573.4199, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_quarts_3() { - let result: f64 = volume::millilitres::to_quarts(129.0); - assert_approx_eq!(0.113504, result, 0.01); + fn it_convert_knownoil_barrels_to_fluid_ounces_3() { + let result: f64 = volume::oil_barrels::to_fluid_ounces(77.0); + assert_approx_eq!(430858.889, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_pints_1() { - let result: f64 = volume::millilitres::to_pints(124.0); - assert_approx_eq!(0.218209, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_teaspoons_1() { + let result: f64 = volume::oil_barrels::to_u_s_teaspoons(0.3); + assert_approx_eq!(9676.8, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_pints_2() { - let result: f64 = volume::millilitres::to_pints(99.0); - assert_approx_eq!(0.174216, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_teaspoons_2() { + let result: f64 = volume::oil_barrels::to_u_s_teaspoons(7.0); + assert_approx_eq!(225792.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_pints_3() { - let result: f64 = volume::millilitres::to_pints(607.3); - assert_approx_eq!(1.0686986, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_teaspoons_3() { + let result: f64 = volume::oil_barrels::to_u_s_teaspoons(1.5); + assert_approx_eq!(48384.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_gallons_1() { - let result: f64 = volume::millilitres::to_gallons(1234.0); - assert_approx_eq!(0.2714421, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_tablespoons_1() { + let result: f64 = volume::oil_barrels::to_u_s_tablespoons(0.2); + assert_approx_eq!(2150.4, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_gallons_2() { - let result: f64 = volume::millilitres::to_gallons(9000.0); - assert_approx_eq!(1.979723, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_tablespoons_2() { + let result: f64 = volume::oil_barrels::to_u_s_tablespoons(6.0); + assert_approx_eq!(64512.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_gallons_3() { - let result: f64 = volume::millilitres::to_gallons(10209.98); - assert_approx_eq!(2.2458816257, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_tablespoons_3() { + let result: f64 = volume::oil_barrels::to_u_s_tablespoons(77.0); + assert_approx_eq!(827904.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_fluid_ounces_1() { - let result: f64 = volume::millilitres::to_fluid_ounces(78.0); - assert_approx_eq!(2.74522, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_quarts_1() { + let result: f64 = volume::oil_barrels::to_u_s_quarts(4.5); + assert_approx_eq!(756.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_fluid_ounces_2() { - let result: f64 = volume::millilitres::to_fluid_ounces(12.9); - assert_approx_eq!(0.4540165, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_quarts_2() { + let result: f64 = volume::oil_barrels::to_u_s_quarts(77.0); + assert_approx_eq!(12936.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_fluid_ounces_3() { - let result: f64 = volume::millilitres::to_fluid_ounces(1009.0); - assert_approx_eq!(35.51184, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_quarts_3() { + let result: f64 = volume::oil_barrels::to_u_s_quarts(0.7); + assert_approx_eq!(117.6, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_teaspoons_1() { - let result: f64 = volume::millilitres::to_u_s_teaspoons(100.0); - assert_approx_eq!(20.2884, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_pints_1() { + let result: f64 = volume::oil_barrels::to_u_s_pints(7.8); + assert_approx_eq!(2620.8, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_teaspoons_2() { - let result: f64 = volume::millilitres::to_u_s_teaspoons(12.3); - assert_approx_eq!(2.495476, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_pints_2() { + let result: f64 = volume::oil_barrels::to_u_s_pints(0.7); + assert_approx_eq!(235.2, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_teaspoons_3() { - let result: f64 = volume::millilitres::to_u_s_teaspoons(69.0); - assert_approx_eq!(13.999, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_pints_3() { + let result: f64 = volume::oil_barrels::to_u_s_pints(3.0); + assert_approx_eq!(1008.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_tablespoons_1() { - let result: f64 = volume::millilitres::to_u_s_tablespoons(38.0); - assert_approx_eq!(2.56987, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_gallons_1() { + let result: f64 = volume::oil_barrels::to_u_s_gallons(78.0); + assert_approx_eq!(3276.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_tablespoons_2() { - let result: f64 = volume::millilitres::to_u_s_tablespoons(1023.0); - assert_approx_eq!(69.18349, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_gallons_2() { + let result: f64 = volume::oil_barrels::to_u_s_gallons(3.0); + assert_approx_eq!(126.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_tablespoons_3() { - let result: f64 = volume::millilitres::to_u_s_tablespoons(88.8); - assert_approx_eq!(6.00537, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_gallons_3() { + let result: f64 = volume::oil_barrels::to_u_s_gallons(777.0); + assert_approx_eq!(32634.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_quarts_1() { - let result: f64 = volume::millilitres::to_u_s_quarts(1009.0); - assert_approx_eq!(1.066198, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_fluid_ounces_1() { + let result: f64 = volume::oil_barrels::to_u_s_fluid_ounces(4.9); + assert_approx_eq!(26342.4, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_quarts_2() { - let result: f64 = volume::millilitres::to_u_s_quarts(4567.0); - assert_approx_eq!(4.825895, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_fluid_ounces_2() { + let result: f64 = volume::oil_barrels::to_u_s_fluid_ounces(0.4); + assert_approx_eq!(2150.4, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_quarts_3() { - let result: f64 = volume::millilitres::to_u_s_quarts(8009.0); - assert_approx_eq!(8.463016, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_fluid_ounces_3() { + let result: f64 = volume::oil_barrels::to_u_s_fluid_ounces(3.0); + assert_approx_eq!(16128.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_pints_1() { - let result: f64 = volume::millilitres::to_u_s_pints(110.0); - assert_approx_eq!(0.232471, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_cups_1() { + let result: f64 = volume::oil_barrels::to_u_s_cups(55.0); + assert_approx_eq!(36434.5849, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_pints_2() { - let result: f64 = volume::millilitres::to_u_s_pints(2032.0); - assert_approx_eq!(4.294381, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_cups_2() { + let result: f64 = volume::oil_barrels::to_u_s_cups(0.686847); + assert_approx_eq!(455.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_pints_3() { - let result: f64 = volume::millilitres::to_u_s_pints(1000.9); - assert_approx_eq!(2.11527846, result, 0.01); + fn it_convert_knownoil_barrels_to_u_s_cups_3() { + let result: f64 = volume::oil_barrels::to_u_s_cups(9.2); + assert_approx_eq!(6094.51, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_gallons_1() { - let result: f64 = volume::millilitres::to_u_s_gallons(5000.0); - assert_approx_eq!(1.32086, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_metres_1() { + let result: f64 = volume::oil_barrels::to_cubic_metres(7.0); + assert_approx_eq!(1.1129112, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_gallons_2() { - let result: f64 = volume::millilitres::to_u_s_gallons(123456.0); - assert_approx_eq!(32.6136249, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_metres_2() { + let result: f64 = volume::oil_barrels::to_cubic_metres(3.0); + assert_approx_eq!(0.476962, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_gallons_3() { - let result: f64 = volume::millilitres::to_u_s_gallons(900.0); - assert_approx_eq!(0.237755, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_metres_3() { + let result: f64 = volume::oil_barrels::to_cubic_metres(78.0); + assert_approx_eq!(12.401, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_fluid_ounces_1() { - let result: f64 = volume::millilitres::to_u_s_fluid_ounces(67.0); - assert_approx_eq!(2.26554, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_feet_1() { + let result: f64 = volume::oil_barrels::to_cubic_feet(88.0); + assert_approx_eq!(494.083, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_fluid_ounces_2() { - let result: f64 = volume::millilitres::to_u_s_fluid_ounces(12.6); - assert_approx_eq!(0.4260567, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_feet_2() { + let result: f64 = volume::oil_barrels::to_cubic_feet(3.0); + assert_approx_eq!(16.8438, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_fluid_ounces_3() { - let result: f64 = volume::millilitres::to_u_s_fluid_ounces(11009.0); - assert_approx_eq!(372.25858, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_feet_3() { + let result: f64 = volume::oil_barrels::to_cubic_feet(11.0); + assert_approx_eq!(61.7604, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_cups_1() { - let result: f64 = volume::millilitres::to_u_s_cups(348.0); - assert_approx_eq!(1.47091, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_inches_1() { + let result: f64 = volume::oil_barrels::to_cubic_inches(100.4); + assert_approx_eq!(974080.8, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_cups_2() { - let result: f64 = volume::millilitres::to_u_s_cups(12.9); - assert_approx_eq!(0.05452511, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_inches_2() { + let result: f64 = volume::oil_barrels::to_cubic_inches(5.0); + assert_approx_eq!(48510.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownmillilitres_to_u_s_cups_3() { - let result: f64 = volume::millilitres::to_u_s_cups(700.0); - assert_approx_eq!(2.95873, result, 0.01); + fn it_convert_knownoil_barrels_to_cubic_inches_3() { + let result: f64 = volume::oil_barrels::to_cubic_inches(66.0); + assert_approx_eq!(640332.0, result, 0.01); } /// Need to convert to parameterized tests @@ -1900,6 +3916,90 @@ mod tests { assert_approx_eq!(121.5361, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_metres_1() { + let result: f64 = volume::pints::to_cubic_metres(21117.0); + assert_approx_eq!(12.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_metres_2() { + let result: f64 = volume::pints::to_cubic_metres(14078.0); + assert_approx_eq!(8.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_metres_3() { + let result: f64 = volume::pints::to_cubic_metres(9999.0); + assert_approx_eq!(5.682044, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_feet_1() { + let result: f64 = volume::pints::to_cubic_feet(44.0); + assert_approx_eq!(0.88299, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_feet_2() { + let result: f64 = volume::pints::to_cubic_feet(1234.0); + assert_approx_eq!(24.76386, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_feet_3() { + let result: f64 = volume::pints::to_cubic_feet(8000.0); + assert_approx_eq!(160.5436, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_inches_1() { + let result: f64 = volume::pints::to_cubic_inches(5.0); + assert_approx_eq!(173.387, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_inches_2() { + let result: f64 = volume::pints::to_cubic_inches(777.0); + assert_approx_eq!(26944.33979, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_cubic_inches_3() { + let result: f64 = volume::pints::to_cubic_inches(35.58511); + assert_approx_eq!(1234.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_oil_barrels_1() { + let result: f64 = volume::pints::to_oil_barrels(1398.89); + assert_approx_eq!(5.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_oil_barrels_2() { + let result: f64 = volume::pints::to_oil_barrels(122.0); + assert_approx_eq!(0.436059, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownpints_to_oil_barrels_3() { + let result: f64 = volume::pints::to_oil_barrels(559.557); + assert_approx_eq!(2.0, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownquarts_to_millilitres_1() { @@ -2215,6 +4315,90 @@ mod tests { assert_approx_eq!(1.104874, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_metres_1() { + let result: f64 = volume::quarts::to_cubic_metres(7918.89); + assert_approx_eq!(9.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_metres_2() { + let result: f64 = volume::quarts::to_cubic_metres(1200.0); + assert_approx_eq!(1.363827, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_metres_3() { + let result: f64 = volume::quarts::to_cubic_metres(8000.0); + assert_approx_eq!(9.09218, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_feet_1() { + let result: f64 = volume::quarts::to_cubic_feet(20.0); + assert_approx_eq!(0.802718, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_feet_2() { + let result: f64 = volume::quarts::to_cubic_feet(800.0); + assert_approx_eq!(32.1087, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_feet_3() { + let result: f64 = volume::quarts::to_cubic_feet(67.0); + assert_approx_eq!(2.68911, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_inches_1() { + let result: f64 = volume::quarts::to_cubic_inches(777.0); + assert_approx_eq!(53888.75729, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_inches_2() { + let result: f64 = volume::quarts::to_cubic_inches(8.16093); + assert_approx_eq!(566.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_cubic_inches_3() { + let result: f64 = volume::quarts::to_cubic_inches(76.0); + assert_approx_eq!(5270.97, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_oil_barrels_1() { + let result: f64 = volume::quarts::to_oil_barrels(839.336); + assert_approx_eq!(6.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_oil_barrels_2() { + let result: f64 = volume::quarts::to_oil_barrels(41.9668); + assert_approx_eq!(0.3, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownquarts_to_oil_barrels_3() { + let result: f64 = volume::quarts::to_oil_barrels(22.0); + assert_approx_eq!(0.157267, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knowntablespoons_to_millilitres_1() { @@ -2530,6 +4714,90 @@ mod tests { assert_approx_eq!(75.0594, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_metres_1() { + let result: f64 = volume::tablespoons::to_cubic_metres(10000.0); + assert_approx_eq!(0.1775817, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_metres_2() { + let result: f64 = volume::tablespoons::to_cubic_metres(3378.726); + assert_approx_eq!(0.059999995422, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_metres_3() { + let result: f64 = volume::tablespoons::to_cubic_metres(800009.0); + assert_approx_eq!(14.2066969, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_feet_1() { + let result: f64 = volume::tablespoons::to_cubic_feet(780.0); + assert_approx_eq!(0.489157, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_feet_2() { + let result: f64 = volume::tablespoons::to_cubic_feet(6378.32); + assert_approx_eq!(4.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_feet_3() { + let result: f64 = volume::tablespoons::to_cubic_feet(8451.28); + assert_approx_eq!(5.3, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_inches_1() { + let result: f64 = volume::tablespoons::to_cubic_inches(66.0); + assert_approx_eq!(71.5222, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_inches_2() { + let result: f64 = volume::tablespoons::to_cubic_inches(123.0); + assert_approx_eq!(133.291, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_cubic_inches_3() { + let result: f64 = volume::tablespoons::to_cubic_inches(56.0); + assert_approx_eq!(60.6855, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_oil_barrels_1() { + let result: f64 = volume::tablespoons::to_oil_barrels(44764.5); + assert_approx_eq!(5.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_oil_barrels_2() { + let result: f64 = volume::tablespoons::to_oil_barrels(12222.0); + assert_approx_eq!(1.3651429, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knowntablespoons_to_oil_barrels_3() { + let result: f64 = volume::tablespoons::to_oil_barrels(800.0); + assert_approx_eq!(0.0893564, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownteaspoons_to_millilitres_1() { @@ -2779,7 +5047,7 @@ mod tests { #[test] fn it_convert_knownteaspoons_to_u_s_pints_3() { let result: f64 = volume::teaspoons::to_u_s_pints(6.21); - assert_approx_eq!(0.07656059, result, 0.01); + assert_approx_eq!(0.07768648, result, 0.01); } /// Need to convert to parameterized tests @@ -2845,6 +5113,90 @@ mod tests { assert_approx_eq!(2.7496761, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_metres_1() { + let result: f64 = volume::teaspoons::to_cubic_metres(152043.0); + assert_approx_eq!(0.9, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_metres_2() { + let result: f64 = volume::teaspoons::to_cubic_metres(3378.726); + assert_approx_eq!(0.02, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_metres_3() { + let result: f64 = volume::teaspoons::to_cubic_metres(8000.0); + assert_approx_eq!(0.04735512, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_feet_1() { + let result: f64 = volume::teaspoons::to_cubic_feet(600.0); + assert_approx_eq!(0.125425, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_feet_2() { + let result: f64 = volume::teaspoons::to_cubic_feet(1234.0); + assert_approx_eq!(0.257957, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_feet_3() { + let result: f64 = volume::teaspoons::to_cubic_feet(880.0); + assert_approx_eq!(0.183956, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_inches_1() { + let result: f64 = volume::teaspoons::to_cubic_inches(8.0); + assert_approx_eq!(2.88979, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_inches_2() { + let result: f64 = volume::teaspoons::to_cubic_inches(12.0); + assert_approx_eq!(4.33468, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_cubic_inches_3() { + let result: f64 = volume::teaspoons::to_cubic_inches(666.0); + assert_approx_eq!(240.575, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_oil_barrels_1() { + let result: f64 = volume::teaspoons::to_oil_barrels(10743.5); + assert_approx_eq!(0.4, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_oil_barrels_2() { + let result: f64 = volume::teaspoons::to_oil_barrels(107435.0); + assert_approx_eq!(4.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownteaspoons_to_oil_barrels_3() { + let result: f64 = volume::teaspoons::to_oil_barrels(134294.0); + assert_approx_eq!(5.0, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownu_s_cups_to_millilitres_1() { @@ -3160,6 +5512,90 @@ mod tests { assert_approx_eq!(7.2, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_metres_1() { + let result: f64 = volume::u_s_cups::to_cubic_metres(4555.0); + assert_approx_eq!(1.0932, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_metres_2() { + let result: f64 = volume::u_s_cups::to_cubic_metres(100900.0); + assert_approx_eq!(24.216, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_metres_3() { + let result: f64 = volume::u_s_cups::to_cubic_metres(7800.0); + assert_approx_eq!(1.872, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_feet_1() { + let result: f64 = volume::u_s_cups::to_cubic_feet(88.0); + assert_approx_eq!(0.745846, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_feet_2() { + let result: f64 = volume::u_s_cups::to_cubic_feet(471.947); + assert_approx_eq!(4.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_feet_3() { + let result: f64 = volume::u_s_cups::to_cubic_feet(123.0); + assert_approx_eq!(1.04249, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_inches_1() { + let result: f64 = volume::u_s_cups::to_cubic_inches(6.0); + assert_approx_eq!(87.8742, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_inches_2() { + let result: f64 = volume::u_s_cups::to_cubic_inches(2.3); + assert_approx_eq!(33.6851, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_cubic_inches_3() { + let result: f64 = volume::u_s_cups::to_cubic_inches(0.9); + assert_approx_eq!(13.1811, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_oil_barrels_1() { + let result: f64 = volume::u_s_cups::to_oil_barrels(43721.5); + assert_approx_eq!(66.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_oil_barrels_2() { + let result: f64 = volume::u_s_cups::to_oil_barrels(1111.0); + assert_approx_eq!(1.677115, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_cups_to_oil_barrels_3() { + let result: f64 = volume::u_s_cups::to_oil_barrels(3312.24); + assert_approx_eq!(5.0, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownu_s_fluid_ounces_to_millilitres_1() { @@ -3456,23 +5892,107 @@ mod tests { /// Need to convert to parameterized tests #[test] - fn it_convert_knownu_s_fluid_ounces_to_u_s_cups_1() { - let result: f64 = volume::u_s_fluid_ounces::to_u_s_cups(45.0); - assert_approx_eq!(5.625, result, 0.01); + fn it_convert_knownu_s_fluid_ounces_to_u_s_cups_1() { + let result: f64 = volume::u_s_fluid_ounces::to_u_s_cups(45.0); + assert_approx_eq!(5.625, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_u_s_cups_2() { + let result: f64 = volume::u_s_fluid_ounces::to_u_s_cups(66.9); + assert_approx_eq!(8.3625, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_u_s_cups_3() { + let result: f64 = volume::u_s_fluid_ounces::to_u_s_cups(0.29); + assert_approx_eq!(0.03625, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_metres_1() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_metres(800900.0); + assert_approx_eq!(23.6854398, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_metres_2() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_metres(789.0); + assert_approx_eq!(0.0233335, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_metres_3() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_metres(100100.0); + assert_approx_eq!(2.96031031, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_feet_1() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_feet(344.0); + assert_approx_eq!(0.359266, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_feet_2() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_feet(8009.0); + assert_approx_eq!(8.364434, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_feet_3() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_feet(3830.03); + assert_approx_eq!(4.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_inches_1() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_inches(66.0); + assert_approx_eq!(119.109, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_inches_2() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_inches(900.0); + assert_approx_eq!(1624.22, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_cubic_inches_3() { + let result: f64 = volume::u_s_fluid_ounces::to_cubic_inches(8.0); + assert_approx_eq!(14.4375, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_fluid_ounces_to_oil_barrels_1() { + let result: f64 = volume::u_s_fluid_ounces::to_oil_barrels(32256.0); + assert_approx_eq!(6.0, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownu_s_fluid_ounces_to_u_s_cups_2() { - let result: f64 = volume::u_s_fluid_ounces::to_u_s_cups(66.9); - assert_approx_eq!(8.3625, result, 0.01); + fn it_convert_knownu_s_fluid_ounces_to_oil_barrels_2() { + let result: f64 = volume::u_s_fluid_ounces::to_oil_barrels(1899.0); + assert_approx_eq!(0.3532366, result, 0.01); } /// Need to convert to parameterized tests #[test] - fn it_convert_knownu_s_fluid_ounces_to_u_s_cups_3() { - let result: f64 = volume::u_s_fluid_ounces::to_u_s_cups(0.29); - assert_approx_eq!(0.03625, result, 0.01); + fn it_convert_knownu_s_fluid_ounces_to_oil_barrels_3() { + let result: f64 = volume::u_s_fluid_ounces::to_oil_barrels(6988.8); + assert_approx_eq!(1.3, result, 0.01); } /// Need to convert to parameterized tests @@ -3790,6 +6310,90 @@ mod tests { assert_approx_eq!(15.68, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_metres_1() { + let result: f64 = volume::u_s_gallons::to_cubic_metres(1849.2); + assert_approx_eq!(7.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_metres_2() { + let result: f64 = volume::u_s_gallons::to_cubic_metres(87.0); + assert_approx_eq!(0.329331, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_metres_3() { + let result: f64 = volume::u_s_gallons::to_cubic_metres(123456.0); + assert_approx_eq!(467.331797, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_feet_1() { + let result: f64 = volume::u_s_gallons::to_cubic_feet(6.0); + assert_approx_eq!(0.802083, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_feet_2() { + let result: f64 = volume::u_s_gallons::to_cubic_feet(24.0); + assert_approx_eq!(3.20833, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_feet_3() { + let result: f64 = volume::u_s_gallons::to_cubic_feet(5.0); + assert_approx_eq!(0.668403, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_inches_1() { + let result: f64 = volume::u_s_gallons::to_cubic_inches(6.0); + assert_approx_eq!(1386.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_inches_2() { + let result: f64 = volume::u_s_gallons::to_cubic_inches(190.0); + assert_approx_eq!(43890.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_cubic_inches_3() { + let result: f64 = volume::u_s_gallons::to_cubic_inches(55.0); + assert_approx_eq!(12705.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_oil_barrels_1() { + let result: f64 = volume::u_s_gallons::to_oil_barrels(966.0); + assert_approx_eq!(23.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_oil_barrels_2() { + let result: f64 = volume::u_s_gallons::to_oil_barrels(1234.0); + assert_approx_eq!(29.38095, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_gallons_to_oil_barrels_3() { + let result: f64 = volume::u_s_gallons::to_oil_barrels(16.8); + assert_approx_eq!(0.4, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownu_s_pints_to_millilitres_1() { @@ -4105,6 +6709,90 @@ mod tests { assert_approx_eq!(91.8, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_metres_1() { + let result: f64 = volume::u_s_pints::to_cubic_metres(14793.6); + assert_approx_eq!(7.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_metres_2() { + let result: f64 = volume::u_s_pints::to_cubic_metres(700.0); + assert_approx_eq!(0.331224, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_metres_3() { + let result: f64 = volume::u_s_pints::to_cubic_metres(123456.0); + assert_approx_eq!(58.4164747, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_feet_1() { + let result: f64 = volume::u_s_pints::to_cubic_feet(66.0); + assert_approx_eq!(1.10286, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_feet_2() { + let result: f64 = volume::u_s_pints::to_cubic_feet(2692.99); + assert_approx_eq!(45.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_feet_3() { + let result: f64 = volume::u_s_pints::to_cubic_feet(123.0); + assert_approx_eq!(2.05534, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_inches_1() { + let result: f64 = volume::u_s_pints::to_cubic_inches(66.0); + assert_approx_eq!(1905.75, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_inches_2() { + let result: f64 = volume::u_s_pints::to_cubic_inches(900.0); + assert_approx_eq!(25987.5, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_cubic_inches_3() { + let result: f64 = volume::u_s_pints::to_cubic_inches(6.7); + assert_approx_eq!(193.463, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_oil_barrels_1() { + let result: f64 = volume::u_s_pints::to_oil_barrels(223776.0); + assert_approx_eq!(666.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_oil_barrels_2() { + let result: f64 = volume::u_s_pints::to_oil_barrels(1234.0); + assert_approx_eq!(3.672619, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_pints_to_oil_barrels_3() { + let result: f64 = volume::u_s_pints::to_oil_barrels(302.4); + assert_approx_eq!(0.9, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownu_s_quarts_to_millilitres_1() { @@ -4420,6 +7108,90 @@ mod tests { assert_approx_eq!(2.64, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_metres_1() { + let result: f64 = volume::u_s_quarts::to_cubic_metres(8453.51); + assert_approx_eq!(8.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_metres_2() { + let result: f64 = volume::u_s_quarts::to_cubic_metres(5000.0); + assert_approx_eq!(4.731765, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_metres_3() { + let result: f64 = volume::u_s_quarts::to_cubic_metres(123456.0); + assert_approx_eq!(116.832949, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_feet_1() { + let result: f64 = volume::u_s_quarts::to_cubic_feet(44.0); + assert_approx_eq!(1.47049, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_feet_2() { + let result: f64 = volume::u_s_quarts::to_cubic_feet(2663.06); + assert_approx_eq!(89.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_feet_3() { + let result: f64 = volume::u_s_quarts::to_cubic_feet(444.0); + assert_approx_eq!(14.8385, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_inches_1() { + let result: f64 = volume::u_s_quarts::to_cubic_inches(44.0); + assert_approx_eq!(2541.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_inches_2() { + let result: f64 = volume::u_s_quarts::to_cubic_inches(800.0); + assert_approx_eq!(46200.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_cubic_inches_3() { + let result: f64 = volume::u_s_quarts::to_cubic_inches(6.0); + assert_approx_eq!(346.5, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_oil_barrels_1() { + let result: f64 = volume::u_s_quarts::to_oil_barrels(9240.0); + assert_approx_eq!(55.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_oil_barrels_2() { + let result: f64 = volume::u_s_quarts::to_oil_barrels(1344.0); + assert_approx_eq!(8.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_quarts_to_oil_barrels_3() { + let result: f64 = volume::u_s_quarts::to_oil_barrels(207312.0); + assert_approx_eq!(1234.0, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownu_s_tablespoons_to_millilitres_1() { @@ -4735,6 +7507,90 @@ mod tests { assert_approx_eq!(562.55625, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_metres_1() { + let result: f64 = volume::u_s_tablespoons::to_cubic_metres(541024.0); + assert_approx_eq!(8.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_metres_2() { + let result: f64 = volume::u_s_tablespoons::to_cubic_metres(10200.0); + assert_approx_eq!(0.150825, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_metres_3() { + let result: f64 = volume::u_s_tablespoons::to_cubic_metres(123456.0); + assert_approx_eq!(1.82551483, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_feet_1() { + let result: f64 = volume::u_s_tablespoons::to_cubic_feet(66.0); + assert_approx_eq!(0.0344645, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_feet_2() { + let result: f64 = volume::u_s_tablespoons::to_cubic_feet(7660.05); + assert_approx_eq!(4.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_feet_3() { + let result: f64 = volume::u_s_tablespoons::to_cubic_feet(1234.0); + assert_approx_eq!(0.6443821, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_inches_1() { + let result: f64 = volume::u_s_tablespoons::to_cubic_inches(900.0); + assert_approx_eq!(812.109, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_inches_2() { + let result: f64 = volume::u_s_tablespoons::to_cubic_inches(10.0); + assert_approx_eq!(9.02344, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_cubic_inches_3() { + let result: f64 = volume::u_s_tablespoons::to_cubic_inches(4.0); + assert_approx_eq!(3.60938, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_oil_barrels_1() { + let result: f64 = volume::u_s_tablespoons::to_oil_barrels(591360.0); + assert_approx_eq!(55.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_oil_barrels_2() { + let result: f64 = volume::u_s_tablespoons::to_oil_barrels(4300.8); + assert_approx_eq!(0.4, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_tablespoons_to_oil_barrels_3() { + let result: f64 = volume::u_s_tablespoons::to_oil_barrels(34406.4); + assert_approx_eq!(3.2, result, 0.01); + } + /// Need to convert to parameterized tests #[test] fn it_convert_knownu_s_teaspoons_to_millilitres_1() { @@ -5050,4 +7906,88 @@ mod tests { assert_approx_eq!(0.01875, result, 0.01); } + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_metres_1() { + let result: f64 = volume::u_s_teaspoons::to_cubic_metres(405768.0); + assert_approx_eq!(2.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_metres_2() { + let result: f64 = volume::u_s_teaspoons::to_cubic_metres(80808.0); + assert_approx_eq!(0.39829617, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_metres_3() { + let result: f64 = volume::u_s_teaspoons::to_cubic_metres(123456.0); + assert_approx_eq!(0.608504748, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_feet_1() { + let result: f64 = volume::u_s_teaspoons::to_cubic_feet(2000.0); + assert_approx_eq!(0.3481263, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_feet_2() { + let result: f64 = volume::u_s_teaspoons::to_cubic_feet(6894.05); + assert_approx_eq!(1.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_feet_3() { + let result: f64 = volume::u_s_teaspoons::to_cubic_feet(12345.0); + assert_approx_eq!(2.1488098, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_inches_1() { + let result: f64 = volume::u_s_teaspoons::to_cubic_inches(23.2727); + assert_approx_eq!(7.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_inches_2() { + let result: f64 = volume::u_s_teaspoons::to_cubic_inches(219.429); + assert_approx_eq!(66.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_cubic_inches_3() { + let result: f64 = volume::u_s_teaspoons::to_cubic_inches(39.8961); + assert_approx_eq!(12.0, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_oil_barrels_1() { + let result: f64 = volume::u_s_teaspoons::to_oil_barrels(103219.0); + assert_approx_eq!(3.2, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_oil_barrels_2() { + let result: f64 = volume::u_s_teaspoons::to_oil_barrels(6666.0); + assert_approx_eq!(0.2066592, result, 0.01); + } + + /// Need to convert to parameterized tests + #[test] + fn it_convert_knownu_s_teaspoons_to_oil_barrels_3() { + let result: f64 = volume::u_s_teaspoons::to_oil_barrels(64512.0); + assert_approx_eq!(2.0, result, 0.01); + } + }