From d60d534014f4c853490195af2ff15cdce36c625f Mon Sep 17 00:00:00 2001 From: Matthew Gamble Date: Tue, 6 Jul 2021 23:30:49 +1000 Subject: [PATCH] Various bits of cleanup suggested by clippy It would be good to incorporate clippy into the CI pipeline once it's up and running. --- src/evaluator.rs | 12 +- src/lib.rs | 8 +- src/parser.rs | 19 ++- src/units.rs | 316 ++++++++++++++++++++++++----------------------- 4 files changed, 177 insertions(+), 178 deletions(-) diff --git a/src/evaluator.rs b/src/evaluator.rs index c75b6c9..c0ade25 100644 --- a/src/evaluator.rs +++ b/src/evaluator.rs @@ -114,7 +114,7 @@ fn evaluate_node(ast_node: &AstNode) -> Result { let result = cbrt(child_answer.value); return Ok(Number::new(result, child_answer.unit)) } else { - return Err(format!("log() only accepts UnitType::NoType").to_string()) + return Err("log() only accepts UnitType::NoType".to_string()) } }, Sqrt => { @@ -122,7 +122,7 @@ fn evaluate_node(ast_node: &AstNode) -> Result { let result = sqrt(child_answer.value); return Ok(Number::new(result, child_answer.unit)) } else { - return Err(format!("log() only accepts UnitType::NoType").to_string()) + return Err("log() only accepts UnitType::NoType".to_string()) } }, Log => { @@ -130,7 +130,7 @@ fn evaluate_node(ast_node: &AstNode) -> Result { let result = child_answer.value.log10(); return Ok(Number::new(result, child_answer.unit)) } else { - return Err(format!("log() only accepts UnitType::NoType").to_string()) + return Err("log() only accepts UnitType::NoType".to_string()) } }, Ln => { @@ -138,7 +138,7 @@ fn evaluate_node(ast_node: &AstNode) -> Result { let result = child_answer.value.ln(); return Ok(Number::new(result, child_answer.unit)) } else { - return Err(format!("ln() only accepts UnitType::NoType").to_string()) + return Err("ln() only accepts UnitType::NoType".to_string()) } }, Exp => { @@ -146,7 +146,7 @@ fn evaluate_node(ast_node: &AstNode) -> Result { let result = child_answer.value.exp(child_answer.value); return Ok(Number::new(result, child_answer.unit)) } else { - return Err(format!("exp() only accepts UnitType::NoType").to_string()) + return Err("exp() only accepts UnitType::NoType".to_string()) } }, Round => { @@ -229,7 +229,7 @@ fn evaluate_node(ast_node: &AstNode) -> Result { Token::TextOperator(operator) => { let left_child = children.get(0).ok_or(format!("Token {:?} has no child[0]", token))?; let right_child = children.get(1).ok_or(format!("Token {:?} has no child[1]", token))?; - + match operator { To => { if let Token::Unit(right_unit) = right_child.token { diff --git a/src/lib.rs b/src/lib.rs index 1c2f4ee..8c30723 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -60,10 +60,7 @@ pub struct Number { impl Number { pub fn new(value: d128, unit: Unit) -> Number { - Number { - value: value, - unit: unit, - } + Number { value, unit } } } impl Display for Number { @@ -258,13 +255,10 @@ pub fn eval(input: &str, allow_trailing_operators: bool, default_degree: Unit, v }, Err(e) => Err(format!("Eval error: {}", e)), } - }, Err(e) => Err(format!("Parsing error: {}", e)), } - }, Err(e) => Err(format!("Lexing error: {}", e)), } - } diff --git a/src/parser.rs b/src/parser.rs index 91984c5..32725c4 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -23,7 +23,7 @@ impl AstNode { } /// Parse [`Token`]s into an Abstract Syntax Tree ([`AstNode`]) -pub fn parse(tokens: &Vec) -> Result { +pub fn parse(tokens: &[Token]) -> Result { parse_level_1(tokens, 0).and_then(|(ast, next_pos)| if next_pos == tokens.len() { Ok(ast) } else { @@ -33,7 +33,7 @@ pub fn parse(tokens: &Vec) -> Result { // level 1 precedence (lowest): to, of /// Parse [`To`](crate::TextOperator::To) and [`Of`](crate::TextOperator::Of) -pub fn parse_level_1(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { +pub fn parse_level_1(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { // do higher precedences first, then come back down let (mut node, mut pos) = parse_level_2(tokens, pos)?; // now we loop through the next tokens @@ -61,7 +61,7 @@ pub fn parse_level_1(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) // level 2 precedence: +, - /// Parse [`Plus`](crate::Operator::Plus) and [`Minus`](crate::Operator::Minus) -pub fn parse_level_2(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { +pub fn parse_level_2(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { let (mut node, mut pos) = parse_level_3(tokens, pos)?; loop { let token = tokens.get(pos); @@ -83,8 +83,7 @@ pub fn parse_level_2(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) // level 3 precedence: *, /, modulo, implicative multiplication, foot-inch 6'4" /// Parse [`Multiply`](crate::Operator::Multiply), [`Divide`](crate::Operator::Divide), [`Modulo`](crate::Operator::Modulo) and implicative multiplication (for example`2pi`) -pub fn parse_level_3(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { - +pub fn parse_level_3(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { // parse foot-inch syntax 6'4" let token0 = tokens.get(pos); if let Some(Token::Number(_number)) = token0 { @@ -116,7 +115,7 @@ pub fn parse_level_3(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) } } } - + let (mut node, mut pos) = parse_level_4(tokens, pos)?; loop { @@ -215,7 +214,7 @@ pub fn parse_level_3(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) // level 4 precedence: ^ /// Parse [`Caret`](crate::Operator::Caret) -pub fn parse_level_4(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { +pub fn parse_level_4(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { let (mut node, mut pos) = parse_level_5(tokens, pos)?; loop { let token = tokens.get(pos); @@ -237,7 +236,7 @@ pub fn parse_level_4(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) // level 5 precedence: - (as in -5, but not 4-5) /// Parse [`Negative`](Token::Negative) -pub fn parse_level_5(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { +pub fn parse_level_5(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { // Here we parse the negative unary operator. If the current token // is a minus, we wrap the right_node inside a Negative AstNode. // @@ -264,7 +263,7 @@ pub fn parse_level_5(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) // level 6 precedence: !, percent, units attached to values /// Parse [`Factorial`](crate::UnaryOperator::Factorial) and [`Percent`](crate::UnaryOperator::Percent) -pub fn parse_level_6(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { +pub fn parse_level_6(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { let (mut node, mut pos) = parse_level_7(tokens, pos)?; loop { let token = tokens.get(pos); @@ -300,7 +299,7 @@ pub fn parse_level_6(tokens: &Vec, pos: usize) -> Result<(AstNode, usize) /// [`Constant`](Token::Constant), /// [`FunctionIdentifier`](Token::FunctionIdentifier), /// [`Paren`](Token::Paren) -pub fn parse_level_7(tokens: &Vec, pos: usize) -> Result<(AstNode, usize), String> { +pub fn parse_level_7(tokens: &[Token], pos: usize) -> Result<(AstNode, usize), String> { let token: &Token = tokens.get(pos).ok_or(format!("Unexpected end of input at {}", pos))?; match token { &Token::Number(_number) => { diff --git a/src/units.rs b/src/units.rs index a04fe57..6a92e0c 100644 --- a/src/units.rs +++ b/src/units.rs @@ -623,7 +623,7 @@ pub fn divide(left: Number, right: Number) -> Result { Ok(to_ideal_unit(Number::new(result, Ampere))) } else if lcat == Energy && rcat == Time { // 1 joule / 1 second = 1 watt - let result = (left.value * left.unit.weight()) / ((right.value * right.unit.weight() / Unit::Second.weight())); + let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight() / Unit::Second.weight()); Ok(to_ideal_unit(Number::new(result, Watt))) } else { Err(format!("Cannot divide {:?} by {:?}", left.unit, right.unit)) @@ -689,6 +689,12 @@ pub fn pow(left: Number, right: Number) -> Result { mod tests { use super::*; + macro_rules! assert_float_eq { + ( $actual:expr, $expected:literal ) => { + assert!(($actual - $expected).abs() < f64::EPSILON); + } + } + #[test] fn test_convert() { pub fn convert_test(value: f64, unit: Unit, to_unit: Unit) -> f64 { @@ -697,179 +703,179 @@ mod tests { let value_string = &value.to_string(); let value_d128 = d128::from_str(value_string).unwrap(); let number = Number::new(value_d128, unit); - + let result = convert(number, to_unit); let string_result = &result.unwrap().value.to_string(); let float_result = f64::from_str(string_result).unwrap(); return float_result; } - assert_eq!(convert_test(1000.0, Nanosecond, Microsecond), 1.0); - assert_eq!(convert_test(1000.0, Nanosecond, Microsecond), 1.0); - assert_eq!(convert_test(1000.0, Microsecond, Millisecond), 1.0); - assert_eq!(convert_test(1000.0, Millisecond, Second), 1.0); - assert_eq!(convert_test(60.0, Second, Minute), 1.0); - assert_eq!(convert_test(60.0, Minute, Hour), 1.0); - assert_eq!(convert_test(24.0, Hour, Day), 1.0); - assert_eq!(convert_test(7.0, Day, Week), 1.0); - assert_eq!(convert_test(30.436875, Day, Month), 1.0); - assert_eq!(convert_test(3.0, Month, Quarter), 1.0); - assert_eq!(convert_test(4.0, Quarter, Year), 1.0); - assert_eq!(convert_test(10.0, Year, Decade), 1.0); - assert_eq!(convert_test(10.0, Decade, Century), 1.0); - assert_eq!(convert_test(10.0, Century, Millenium), 1.0); - assert_eq!(convert_test(10.0, Millimeter, Centimeter), 1.0); - assert_eq!(convert_test(10.0, Centimeter, Decimeter), 1.0); - assert_eq!(convert_test(10.0, Decimeter, Meter), 1.0); - assert_eq!(convert_test(1000.0, Meter, Kilometer), 1.0); - assert_eq!(convert_test(2.54, Centimeter, Inch), 1.0); - assert_eq!(convert_test(12.0, Inch, Foot), 1.0); - assert_eq!(convert_test(3.0, Foot, Yard), 1.0); - assert_eq!(convert_test(1760.0, Yard, Mile), 1.0); - assert_eq!(convert_test(1852.0, Meter, NauticalMile), 1.0); - assert_eq!(convert_test(9460730472580800.0, Meter, LightYear), 1.0); - assert_eq!(convert_test(299792458.0, Meter, LightSecond), 1.0); - - assert_eq!(convert_test(100.0, SquareMillimeter, SquareCentimeter), 1.0); - assert_eq!(convert_test(100.0, SquareCentimeter, SquareDecimeter), 1.0); - assert_eq!(convert_test(100.0, SquareDecimeter, SquareMeter), 1.0); - assert_eq!(convert_test(1000000.0, SquareMeter, SquareKilometer), 1.0); - assert_eq!(convert_test(645.16, SquareMillimeter, SquareInch), 1.0); - assert_eq!(convert_test(144.0, SquareInch, SquareFoot), 1.0); - assert_eq!(convert_test(9.0, SquareFoot, SquareYard), 1.0); - assert_eq!(convert_test(3097600.0, SquareYard, SquareMile), 1.0); - assert_eq!(convert_test(100.0, SquareMeter, Are), 1.0); - assert_eq!(convert_test(10.0, Are, Decare), 1.0); - assert_eq!(convert_test(10.0, Decare, Hectare), 1.0); - assert_eq!(convert_test(640.0, Acre, SquareMile), 1.0); + assert_float_eq!(convert_test(1000.0, Nanosecond, Microsecond), 1.0); + assert_float_eq!(convert_test(1000.0, Nanosecond, Microsecond), 1.0); + assert_float_eq!(convert_test(1000.0, Microsecond, Millisecond), 1.0); + assert_float_eq!(convert_test(1000.0, Millisecond, Second), 1.0); + assert_float_eq!(convert_test(60.0, Second, Minute), 1.0); + assert_float_eq!(convert_test(60.0, Minute, Hour), 1.0); + assert_float_eq!(convert_test(24.0, Hour, Day), 1.0); + assert_float_eq!(convert_test(7.0, Day, Week), 1.0); + assert_float_eq!(convert_test(30.436875, Day, Month), 1.0); + assert_float_eq!(convert_test(3.0, Month, Quarter), 1.0); + assert_float_eq!(convert_test(4.0, Quarter, Year), 1.0); + assert_float_eq!(convert_test(10.0, Year, Decade), 1.0); + assert_float_eq!(convert_test(10.0, Decade, Century), 1.0); + assert_float_eq!(convert_test(10.0, Century, Millenium), 1.0); - assert_eq!(convert_test(1000.0, CubicMillimeter, CubicCentimeter), 1.0); - assert_eq!(convert_test(1000.0, CubicCentimeter, CubicDecimeter), 1.0); - assert_eq!(convert_test(1000.0, CubicDecimeter, CubicMeter), 1.0); - assert_eq!(convert_test(1000000000.0, CubicMeter, CubicKilometer), 1.0); - assert_eq!(convert_test(1728.0, CubicInch, CubicFoot), 1.0); - assert_eq!(convert_test(27.0, CubicFoot, CubicYard), 1.0); - assert_eq!(convert_test(5451776000.0, CubicYard, CubicMile), 1.0); - assert_eq!(convert_test(1.0, Milliliter, CubicCentimeter), 1.0); - assert_eq!(convert_test(10.0, Milliliter, Centiliter), 1.0); - assert_eq!(convert_test(10.0, Centiliter, Deciliter), 1.0); - assert_eq!(convert_test(10.0, Deciliter, Liter), 1.0); - assert_eq!(convert_test(4.92892159375, Milliliter, Teaspoon), 1.0); - assert_eq!(convert_test(3.0, Teaspoon, Tablespoon), 1.0); - assert_eq!(convert_test(2.0, Tablespoon, FluidOunce), 1.0); - assert_eq!(convert_test(8.0, FluidOunce, Cup), 1.0); - assert_eq!(convert_test(2.0, Cup, Pint), 1.0); - assert_eq!(convert_test(2.0, Pint, Quart), 1.0); - assert_eq!(convert_test(4.0, Quart, Gallon), 1.0); - assert_eq!(convert_test(42.0, Gallon, OilBarrel), 1.0); + assert_float_eq!(convert_test(10.0, Millimeter, Centimeter), 1.0); + assert_float_eq!(convert_test(10.0, Centimeter, Decimeter), 1.0); + assert_float_eq!(convert_test(10.0, Decimeter, Meter), 1.0); + assert_float_eq!(convert_test(1000.0, Meter, Kilometer), 1.0); + assert_float_eq!(convert_test(2.54, Centimeter, Inch), 1.0); + assert_float_eq!(convert_test(12.0, Inch, Foot), 1.0); + assert_float_eq!(convert_test(3.0, Foot, Yard), 1.0); + assert_float_eq!(convert_test(1760.0, Yard, Mile), 1.0); + assert_float_eq!(convert_test(1852.0, Meter, NauticalMile), 1.0); + assert_float_eq!(convert_test(9460730472580800.0, Meter, LightYear), 1.0); + assert_float_eq!(convert_test(299792458.0, Meter, LightSecond), 1.0); - assert_eq!(convert_test(1000.0, Milligram, Gram), 1.0); - assert_eq!(convert_test(100.0, Gram, Hectogram), 1.0); - assert_eq!(convert_test(1000.0, Gram, Kilogram), 1.0); - assert_eq!(convert_test(1000.0, Kilogram, MetricTon), 1.0); - assert_eq!(convert_test(0.45359237, Kilogram, Pound), 1.0); - assert_eq!(convert_test(16.0, Ounce, Pound), 1.0); - assert_eq!(convert_test(14.0, Pound, Stone), 1.0); - assert_eq!(convert_test(2000.0, Pound, ShortTon), 1.0); - assert_eq!(convert_test(2240.0, Pound, LongTon), 1.0); + assert_float_eq!(convert_test(100.0, SquareMillimeter, SquareCentimeter), 1.0); + assert_float_eq!(convert_test(100.0, SquareCentimeter, SquareDecimeter), 1.0); + assert_float_eq!(convert_test(100.0, SquareDecimeter, SquareMeter), 1.0); + assert_float_eq!(convert_test(1000000.0, SquareMeter, SquareKilometer), 1.0); + assert_float_eq!(convert_test(645.16, SquareMillimeter, SquareInch), 1.0); + assert_float_eq!(convert_test(144.0, SquareInch, SquareFoot), 1.0); + assert_float_eq!(convert_test(9.0, SquareFoot, SquareYard), 1.0); + assert_float_eq!(convert_test(3097600.0, SquareYard, SquareMile), 1.0); + assert_float_eq!(convert_test(100.0, SquareMeter, Are), 1.0); + assert_float_eq!(convert_test(10.0, Are, Decare), 1.0); + assert_float_eq!(convert_test(10.0, Decare, Hectare), 1.0); + assert_float_eq!(convert_test(640.0, Acre, SquareMile), 1.0); - assert_eq!(convert_test(1000.0, Bit, Kilobit), 1.0); - assert_eq!(convert_test(1000.0, Kilobit, Megabit), 1.0); - assert_eq!(convert_test(1000.0, Megabit, Gigabit), 1.0); - assert_eq!(convert_test(1000.0, Gigabit, Terabit), 1.0); - assert_eq!(convert_test(1000.0, Terabit, Petabit), 1.0); - assert_eq!(convert_test(1000.0, Petabit, Exabit), 1.0); - assert_eq!(convert_test(1000.0, Exabit, Zettabit), 1.0); - assert_eq!(convert_test(1000.0, Zettabit, Yottabit), 1.0); - assert_eq!(convert_test(1024.0, Bit, Kibibit), 1.0); - assert_eq!(convert_test(1024.0, Kibibit, Mebibit), 1.0); - assert_eq!(convert_test(1024.0, Mebibit, Gibibit), 1.0); - assert_eq!(convert_test(1024.0, Gibibit, Tebibit), 1.0); - assert_eq!(convert_test(1024.0, Tebibit, Pebibit), 1.0); - assert_eq!(convert_test(1024.0, Pebibit, Exbibit), 1.0); - assert_eq!(convert_test(1024.0, Exbibit, Zebibit), 1.0); - assert_eq!(convert_test(1024.0, Zebibit, Yobibit), 1.0); - assert_eq!(convert_test(8.0, Bit, Byte), 1.0); - assert_eq!(convert_test(1000.0, Byte, Kilobyte), 1.0); - assert_eq!(convert_test(1000.0, Kilobyte, Megabyte), 1.0); - assert_eq!(convert_test(1000.0, Megabyte, Gigabyte), 1.0); - assert_eq!(convert_test(1000.0, Gigabyte, Terabyte), 1.0); - assert_eq!(convert_test(1000.0, Terabyte, Petabyte), 1.0); - assert_eq!(convert_test(1000.0, Petabyte, Exabyte), 1.0); - assert_eq!(convert_test(1000.0, Exabyte, Zettabyte), 1.0); - assert_eq!(convert_test(1000.0, Zettabyte, Yottabyte), 1.0); - assert_eq!(convert_test(1024.0, Kibibyte, Mebibyte), 1.0); - assert_eq!(convert_test(1024.0, Mebibyte, Gibibyte), 1.0); - assert_eq!(convert_test(1024.0, Gibibyte, Tebibyte), 1.0); - assert_eq!(convert_test(1024.0, Tebibyte, Pebibyte), 1.0); - assert_eq!(convert_test(1024.0, Pebibyte, Exbibyte), 1.0); - assert_eq!(convert_test(1024.0, Exbibyte, Zebibyte), 1.0); - assert_eq!(convert_test(1024.0, Zebibyte, Yobibyte), 1.0); + assert_float_eq!(convert_test(1000.0, CubicMillimeter, CubicCentimeter), 1.0); + assert_float_eq!(convert_test(1000.0, CubicCentimeter, CubicDecimeter), 1.0); + assert_float_eq!(convert_test(1000.0, CubicDecimeter, CubicMeter), 1.0); + assert_float_eq!(convert_test(1000000000.0, CubicMeter, CubicKilometer), 1.0); + assert_float_eq!(convert_test(1728.0, CubicInch, CubicFoot), 1.0); + assert_float_eq!(convert_test(27.0, CubicFoot, CubicYard), 1.0); + assert_float_eq!(convert_test(5451776000.0, CubicYard, CubicMile), 1.0); + assert_float_eq!(convert_test(1.0, Milliliter, CubicCentimeter), 1.0); + assert_float_eq!(convert_test(10.0, Milliliter, Centiliter), 1.0); + assert_float_eq!(convert_test(10.0, Centiliter, Deciliter), 1.0); + assert_float_eq!(convert_test(10.0, Deciliter, Liter), 1.0); + assert_float_eq!(convert_test(4.92892159375, Milliliter, Teaspoon), 1.0); + assert_float_eq!(convert_test(3.0, Teaspoon, Tablespoon), 1.0); + assert_float_eq!(convert_test(2.0, Tablespoon, FluidOunce), 1.0); + assert_float_eq!(convert_test(8.0, FluidOunce, Cup), 1.0); + assert_float_eq!(convert_test(2.0, Cup, Pint), 1.0); + assert_float_eq!(convert_test(2.0, Pint, Quart), 1.0); + assert_float_eq!(convert_test(4.0, Quart, Gallon), 1.0); + assert_float_eq!(convert_test(42.0, Gallon, OilBarrel), 1.0); + assert_float_eq!(convert_test(1000.0, Milligram, Gram), 1.0); + assert_float_eq!(convert_test(100.0, Gram, Hectogram), 1.0); + assert_float_eq!(convert_test(1000.0, Gram, Kilogram), 1.0); + assert_float_eq!(convert_test(1000.0, Kilogram, MetricTon), 1.0); + assert_float_eq!(convert_test(0.45359237, Kilogram, Pound), 1.0); + assert_float_eq!(convert_test(16.0, Ounce, Pound), 1.0); + assert_float_eq!(convert_test(14.0, Pound, Stone), 1.0); + assert_float_eq!(convert_test(2000.0, Pound, ShortTon), 1.0); + assert_float_eq!(convert_test(2240.0, Pound, LongTon), 1.0); - assert_eq!(convert_test(1000.0, Millijoule, Joule), 1.0); - assert_eq!(convert_test(1000.0, Joule, Kilojoule), 1.0); - assert_eq!(convert_test(1.0, NewtonMeter, Joule), 1.0); - assert_eq!(convert_test(1000.0, Kilojoule, Megajoule), 1.0); - assert_eq!(convert_test(1000.0, Megajoule, Gigajoule), 1.0); - assert_eq!(convert_test(1000.0, Gigajoule, Terajoule), 1.0); - assert_eq!(convert_test(4.1868, Joule, Calorie), 1.0); - assert_eq!(convert_test(1000.0, Calorie, KiloCalorie), 1.0); - assert_eq!(convert_test(1055.05585262, Joule, BritishThermalUnit), 1.0); - assert_eq!(convert_test(3600.0, Joule, WattHour), 1.0); - assert_eq!(convert_test(1000.0, WattHour, KilowattHour), 1.0); - assert_eq!(convert_test(1000.0, KilowattHour, MegawattHour), 1.0); - assert_eq!(convert_test(1000.0, MegawattHour, GigawattHour), 1.0); - assert_eq!(convert_test(1000.0, GigawattHour, TerawattHour), 1.0); - assert_eq!(convert_test(1000.0, TerawattHour, PetawattHour), 1.0); + assert_float_eq!(convert_test(1000.0, Bit, Kilobit), 1.0); + assert_float_eq!(convert_test(1000.0, Kilobit, Megabit), 1.0); + assert_float_eq!(convert_test(1000.0, Megabit, Gigabit), 1.0); + assert_float_eq!(convert_test(1000.0, Gigabit, Terabit), 1.0); + assert_float_eq!(convert_test(1000.0, Terabit, Petabit), 1.0); + assert_float_eq!(convert_test(1000.0, Petabit, Exabit), 1.0); + assert_float_eq!(convert_test(1000.0, Exabit, Zettabit), 1.0); + assert_float_eq!(convert_test(1000.0, Zettabit, Yottabit), 1.0); + assert_float_eq!(convert_test(1024.0, Bit, Kibibit), 1.0); + assert_float_eq!(convert_test(1024.0, Kibibit, Mebibit), 1.0); + assert_float_eq!(convert_test(1024.0, Mebibit, Gibibit), 1.0); + assert_float_eq!(convert_test(1024.0, Gibibit, Tebibit), 1.0); + assert_float_eq!(convert_test(1024.0, Tebibit, Pebibit), 1.0); + assert_float_eq!(convert_test(1024.0, Pebibit, Exbibit), 1.0); + assert_float_eq!(convert_test(1024.0, Exbibit, Zebibit), 1.0); + assert_float_eq!(convert_test(1024.0, Zebibit, Yobibit), 1.0); + assert_float_eq!(convert_test(8.0, Bit, Byte), 1.0); + assert_float_eq!(convert_test(1000.0, Byte, Kilobyte), 1.0); + assert_float_eq!(convert_test(1000.0, Kilobyte, Megabyte), 1.0); + assert_float_eq!(convert_test(1000.0, Megabyte, Gigabyte), 1.0); + assert_float_eq!(convert_test(1000.0, Gigabyte, Terabyte), 1.0); + assert_float_eq!(convert_test(1000.0, Terabyte, Petabyte), 1.0); + assert_float_eq!(convert_test(1000.0, Petabyte, Exabyte), 1.0); + assert_float_eq!(convert_test(1000.0, Exabyte, Zettabyte), 1.0); + assert_float_eq!(convert_test(1000.0, Zettabyte, Yottabyte), 1.0); + assert_float_eq!(convert_test(1024.0, Kibibyte, Mebibyte), 1.0); + assert_float_eq!(convert_test(1024.0, Mebibyte, Gibibyte), 1.0); + assert_float_eq!(convert_test(1024.0, Gibibyte, Tebibyte), 1.0); + assert_float_eq!(convert_test(1024.0, Tebibyte, Pebibyte), 1.0); + assert_float_eq!(convert_test(1024.0, Pebibyte, Exbibyte), 1.0); + assert_float_eq!(convert_test(1024.0, Exbibyte, Zebibyte), 1.0); + assert_float_eq!(convert_test(1024.0, Zebibyte, Yobibyte), 1.0); - assert_eq!(convert_test(1000.0, Milliwatt, Watt), 1.0); - assert_eq!(convert_test(1000.0, Watt, Kilowatt), 1.0); - assert_eq!(convert_test(1000.0, Kilowatt, Megawatt), 1.0); - assert_eq!(convert_test(1000.0, Megawatt, Gigawatt), 1.0); - assert_eq!(convert_test(1000.0, Gigawatt, Terawatt), 1.0); - assert_eq!(convert_test(1000.0, Terawatt, Petawatt), 1.0); - assert_eq!(convert_test(0.0568690272188, Watt, BritishThermalUnitsPerMinute), 1.0); - assert_eq!(convert_test(60.0, BritishThermalUnitsPerMinute, BritishThermalUnitsPerHour), 1.0); - assert_eq!(convert_test(745.6998715822702, Watt, Horsepower), 1.0); - assert_eq!(convert_test(735.49875, Watt, MetricHorsepower), 1.0); + assert_float_eq!(convert_test(1000.0, Millijoule, Joule), 1.0); + assert_float_eq!(convert_test(1000.0, Joule, Kilojoule), 1.0); + assert_float_eq!(convert_test(1.0, NewtonMeter, Joule), 1.0); + assert_float_eq!(convert_test(1000.0, Kilojoule, Megajoule), 1.0); + assert_float_eq!(convert_test(1000.0, Megajoule, Gigajoule), 1.0); + assert_float_eq!(convert_test(1000.0, Gigajoule, Terajoule), 1.0); + assert_float_eq!(convert_test(4.1868, Joule, Calorie), 1.0); + assert_float_eq!(convert_test(1000.0, Calorie, KiloCalorie), 1.0); + assert_float_eq!(convert_test(1055.05585262, Joule, BritishThermalUnit), 1.0); + assert_float_eq!(convert_test(3600.0, Joule, WattHour), 1.0); + assert_float_eq!(convert_test(1000.0, WattHour, KilowattHour), 1.0); + assert_float_eq!(convert_test(1000.0, KilowattHour, MegawattHour), 1.0); + assert_float_eq!(convert_test(1000.0, MegawattHour, GigawattHour), 1.0); + assert_float_eq!(convert_test(1000.0, GigawattHour, TerawattHour), 1.0); + assert_float_eq!(convert_test(1000.0, TerawattHour, PetawattHour), 1.0); - assert_eq!(convert_test(1000.0, Milliampere, Ampere), 1.0); - assert_eq!(convert_test(1000.0, Ampere, Kiloampere), 1.0); - assert_eq!(convert_test(10.0, Ampere, Abampere), 1.0); + assert_float_eq!(convert_test(1000.0, Milliwatt, Watt), 1.0); + assert_float_eq!(convert_test(1000.0, Watt, Kilowatt), 1.0); + assert_float_eq!(convert_test(1000.0, Kilowatt, Megawatt), 1.0); + assert_float_eq!(convert_test(1000.0, Megawatt, Gigawatt), 1.0); + assert_float_eq!(convert_test(1000.0, Gigawatt, Terawatt), 1.0); + assert_float_eq!(convert_test(1000.0, Terawatt, Petawatt), 1.0); + assert_float_eq!(convert_test(0.0568690272188, Watt, BritishThermalUnitsPerMinute), 1.0); + assert_float_eq!(convert_test(60.0, BritishThermalUnitsPerMinute, BritishThermalUnitsPerHour), 1.0); + assert_float_eq!(convert_test(745.6998715822702, Watt, Horsepower), 1.0); + assert_float_eq!(convert_test(735.49875, Watt, MetricHorsepower), 1.0); - assert_eq!(convert_test(1000.0, Milliohm, Ohm), 1.0); - assert_eq!(convert_test(1000.0, Ohm, Kiloohm), 1.0); + assert_float_eq!(convert_test(1000.0, Milliampere, Ampere), 1.0); + assert_float_eq!(convert_test(1000.0, Ampere, Kiloampere), 1.0); + assert_float_eq!(convert_test(10.0, Ampere, Abampere), 1.0); - assert_eq!(convert_test(1000.0, Millivolt, Volt), 1.0); - assert_eq!(convert_test(1000.0, Volt, Kilovolt), 1.0); + assert_float_eq!(convert_test(1000.0, Milliohm, Ohm), 1.0); + assert_float_eq!(convert_test(1000.0, Ohm, Kiloohm), 1.0); - assert_eq!(convert_test(1000.0, Pascal, Kilopascal), 1.0); - assert_eq!(convert_test(101325.0, Pascal, Atmosphere), 1.0); - assert_eq!(convert_test(100.0, Pascal, Millibar), 1.0); - assert_eq!(convert_test(1000.0, Millibar, Bar), 1.0); - assert_eq!(convert_test(3386.389, Pascal, InchOfMercury), 1.0); - assert_eq!(convert_test(6894.757293168361, Pascal, PoundsPerSquareInch), 1.0); - assert_eq!(convert_test(162.12, Pascal, Torr), 1.0); + assert_float_eq!(convert_test(1000.0, Millivolt, Volt), 1.0); + assert_float_eq!(convert_test(1000.0, Volt, Kilovolt), 1.0); - assert_eq!(convert_test(1000.0, Hertz, Kilohertz), 1.0); - assert_eq!(convert_test(1000.0, Kilohertz, Megahertz), 1.0); - assert_eq!(convert_test(1000.0, Megahertz, Gigahertz), 1.0); - assert_eq!(convert_test(1000.0, Gigahertz, Terahertz), 1.0); - assert_eq!(convert_test(1000.0, Terahertz, Petahertz), 1.0); - assert_eq!(convert_test(60.0, Hertz, RevolutionsPerMinute), 1.0); + assert_float_eq!(convert_test(1000.0, Pascal, Kilopascal), 1.0); + assert_float_eq!(convert_test(101325.0, Pascal, Atmosphere), 1.0); + assert_float_eq!(convert_test(100.0, Pascal, Millibar), 1.0); + assert_float_eq!(convert_test(1000.0, Millibar, Bar), 1.0); + assert_float_eq!(convert_test(3386.389, Pascal, InchOfMercury), 1.0); + assert_float_eq!(convert_test(6894.757293168361, Pascal, PoundsPerSquareInch), 1.0); + assert_float_eq!(convert_test(162.12, Pascal, Torr), 1.0); - assert_eq!(convert_test(3.6, KilometersPerHour, MetersPerSecond), 1.0); - assert_eq!(convert_test(0.3048, MetersPerSecond, FeetPerSecond), 1.0); - assert_eq!(convert_test(1.609344, KilometersPerHour, MilesPerHour), 1.0); - assert_eq!(convert_test(1.852, KilometersPerHour, Knot), 1.0); + assert_float_eq!(convert_test(1000.0, Hertz, Kilohertz), 1.0); + assert_float_eq!(convert_test(1000.0, Kilohertz, Megahertz), 1.0); + assert_float_eq!(convert_test(1000.0, Megahertz, Gigahertz), 1.0); + assert_float_eq!(convert_test(1000.0, Gigahertz, Terahertz), 1.0); + assert_float_eq!(convert_test(1000.0, Terahertz, Petahertz), 1.0); + assert_float_eq!(convert_test(60.0, Hertz, RevolutionsPerMinute), 1.0); - assert_eq!(convert_test(274.15, Kelvin, Celsius), 1.0); - assert_eq!(convert_test(300.0, Kelvin, Fahrenheit), 80.33); - assert_eq!(convert_test(-272.15, Celsius, Kelvin), 1.0); - assert_eq!(convert_test(-15.0, Celsius, Fahrenheit), 5.0); - assert_eq!(convert_test(80.33, Fahrenheit, Kelvin), 300.0); - assert_eq!(convert_test(5.0, Fahrenheit, Celsius), -15.0); + assert_float_eq!(convert_test(3.6, KilometersPerHour, MetersPerSecond), 1.0); + assert_float_eq!(convert_test(0.3048, MetersPerSecond, FeetPerSecond), 1.0); + assert_float_eq!(convert_test(1.609344, KilometersPerHour, MilesPerHour), 1.0); + assert_float_eq!(convert_test(1.852, KilometersPerHour, Knot), 1.0); + + assert_float_eq!(convert_test(274.15, Kelvin, Celsius), 1.0); + assert_float_eq!(convert_test(300.0, Kelvin, Fahrenheit), 80.33); + assert_float_eq!(convert_test(-272.15, Celsius, Kelvin), 1.0); + assert_float_eq!(convert_test(-15.0, Celsius, Fahrenheit), 5.0); + assert_float_eq!(convert_test(80.33, Fahrenheit, Kelvin), 300.0); + assert_float_eq!(convert_test(5.0, Fahrenheit, Celsius), -15.0); } }