// <auto-generated>
// This code was generated by the UnitCodeGenerator tool
//
// Changes to this file will be lost if the code is regenerated
// </auto-generated>


#[cfg(test)]
mod tests {
	use unit_conversions::*;
	use assert_approx_eq::assert_approx_eq;

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_milligrams_1() {
		let result: f64 = mass::carats::to_milligrams(2.1);
		assert_approx_eq!(420.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_milligrams_2() {
		let result: f64 = mass::carats::to_milligrams(123.0);
		assert_approx_eq!(24600.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_milligrams_3() {
		let result: f64 = mass::carats::to_milligrams(0.8);
		assert_approx_eq!(160.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_grams_1() {
		let result: f64 = mass::carats::to_grams(0.8);
		assert_approx_eq!(0.16, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_grams_2() {
		let result: f64 = mass::carats::to_grams(1.5);
		assert_approx_eq!(0.3, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_grams_3() {
		let result: f64 = mass::carats::to_grams(12.0);
		assert_approx_eq!(2.4, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_kilograms_1() {
		let result: f64 = mass::carats::to_kilograms(1009.0);
		assert_approx_eq!(0.2018, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_kilograms_2() {
		let result: f64 = mass::carats::to_kilograms(999.0);
		assert_approx_eq!(0.1998, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_kilograms_3() {
		let result: f64 = mass::carats::to_kilograms(1234.5);
		assert_approx_eq!(0.2469, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_tonnes_1() {
		let result: f64 = mass::carats::to_tonnes(1234567.0);
		assert_approx_eq!(0.2469134, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_tonnes_2() {
		let result: f64 = mass::carats::to_tonnes(9999999.0);
		assert_approx_eq!(1.9999998, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_tonnes_3() {
		let result: f64 = mass::carats::to_tonnes(998877.99);
		assert_approx_eq!(0.199775598, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_ounces_1() {
		let result: f64 = mass::carats::to_ounces(900.0);
		assert_approx_eq!(6.34931, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_ounces_2() {
		let result: f64 = mass::carats::to_ounces(123.45);
		assert_approx_eq!(0.870914121, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_ounces_3() {
		let result: f64 = mass::carats::to_ounces(800.0);
		assert_approx_eq!(5.64383, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_pounds_1() {
		let result: f64 = mass::carats::to_pounds(1000.0);
		assert_approx_eq!(0.440925, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_pounds_2() {
		let result: f64 = mass::carats::to_pounds(123456.0);
		assert_approx_eq!(54.4347781, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_pounds_3() {
		let result: f64 = mass::carats::to_pounds(800.0);
		assert_approx_eq!(0.35274, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_stones_1() {
		let result: f64 = mass::carats::to_stones(9000.0);
		assert_approx_eq!(0.2834515, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_stones_2() {
		let result: f64 = mass::carats::to_stones(123456.0);
		assert_approx_eq!(3.88819843, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowncarats_to_stones_3() {
		let result: f64 = mass::carats::to_stones(80000.8);
		assert_approx_eq!(2.519593906, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_milligrams_1() {
		let result: f64 = mass::grams::to_milligrams(1.2);
		assert_approx_eq!(1200.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_milligrams_2() {
		let result: f64 = mass::grams::to_milligrams(0.9);
		assert_approx_eq!(900.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_milligrams_3() {
		let result: f64 = mass::grams::to_milligrams(2.0);
		assert_approx_eq!(2000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_kilograms_1() {
		let result: f64 = mass::grams::to_kilograms(900.0);
		assert_approx_eq!(0.9, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_kilograms_2() {
		let result: f64 = mass::grams::to_kilograms(12345.0);
		assert_approx_eq!(12.345, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_kilograms_3() {
		let result: f64 = mass::grams::to_kilograms(670.0);
		assert_approx_eq!(0.67, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_tonnes_1() {
		let result: f64 = mass::grams::to_tonnes(6700000.0);
		assert_approx_eq!(6.7, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_tonnes_2() {
		let result: f64 = mass::grams::to_tonnes(123456.0);
		assert_approx_eq!(0.123456, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_tonnes_3() {
		let result: f64 = mass::grams::to_tonnes(9809789.0);
		assert_approx_eq!(9.809789, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_ounces_1() {
		let result: f64 = mass::grams::to_ounces(4.3);
		assert_approx_eq!(0.151678, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_ounces_2() {
		let result: f64 = mass::grams::to_ounces(170.0);
		assert_approx_eq!(5.99657, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_ounces_3() {
		let result: f64 = mass::grams::to_ounces(9.0);
		assert_approx_eq!(0.317466, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_pounds_1() {
		let result: f64 = mass::grams::to_pounds(80.0);
		assert_approx_eq!(0.17637, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_pounds_2() {
		let result: f64 = mass::grams::to_pounds(190.0);
		assert_approx_eq!(0.418878, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_pounds_3() {
		let result: f64 = mass::grams::to_pounds(4500.0);
		assert_approx_eq!(9.920802, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_stones_1() {
		let result: f64 = mass::grams::to_stones(8000.0);
		assert_approx_eq!(1.259784, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_stones_2() {
		let result: f64 = mass::grams::to_stones(12345.0);
		assert_approx_eq!(1.9440047, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_stones_3() {
		let result: f64 = mass::grams::to_stones(900.0);
		assert_approx_eq!(0.141726, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_carats_1() {
		let result: f64 = mass::grams::to_carats(123.0);
		assert_approx_eq!(615.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_carats_2() {
		let result: f64 = mass::grams::to_carats(90.1);
		assert_approx_eq!(450.5, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowngrams_to_carats_3() {
		let result: f64 = mass::grams::to_carats(5000.0);
		assert_approx_eq!(25000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_milligrams_1() {
		let result: f64 = mass::kilograms::to_milligrams(0.9);
		assert_approx_eq!(900000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_milligrams_2() {
		let result: f64 = mass::kilograms::to_milligrams(0.56);
		assert_approx_eq!(560000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_milligrams_3() {
		let result: f64 = mass::kilograms::to_milligrams(0.007);
		assert_approx_eq!(7000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_grams_1() {
		let result: f64 = mass::kilograms::to_grams(0.8);
		assert_approx_eq!(800.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_grams_2() {
		let result: f64 = mass::kilograms::to_grams(12.0);
		assert_approx_eq!(12000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_grams_3() {
		let result: f64 = mass::kilograms::to_grams(0.2);
		assert_approx_eq!(200.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_tonnes_1() {
		let result: f64 = mass::kilograms::to_tonnes(123.0);
		assert_approx_eq!(0.123, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_tonnes_2() {
		let result: f64 = mass::kilograms::to_tonnes(9000.0);
		assert_approx_eq!(9.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_tonnes_3() {
		let result: f64 = mass::kilograms::to_tonnes(2300.0);
		assert_approx_eq!(2.3, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_ounces_1() {
		let result: f64 = mass::kilograms::to_ounces(2300.0);
		assert_approx_eq!(81130.19, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_ounces_2() {
		let result: f64 = mass::kilograms::to_ounces(12.0);
		assert_approx_eq!(423.288, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_ounces_3() {
		let result: f64 = mass::kilograms::to_ounces(3.4);
		assert_approx_eq!(119.931, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_pounds_1() {
		let result: f64 = mass::kilograms::to_pounds(3.4);
		assert_approx_eq!(7.49572, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_pounds_2() {
		let result: f64 = mass::kilograms::to_pounds(0.9);
		assert_approx_eq!(1.98416, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_pounds_3() {
		let result: f64 = mass::kilograms::to_pounds(3.0);
		assert_approx_eq!(6.61387, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_stones_1() {
		let result: f64 = mass::kilograms::to_stones(3.0);
		assert_approx_eq!(0.472419, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_stones_2() {
		let result: f64 = mass::kilograms::to_stones(98.0);
		assert_approx_eq!(15.4324, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_stones_3() {
		let result: f64 = mass::kilograms::to_stones(1.2);
		assert_approx_eq!(0.188968, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_carats_1() {
		let result: f64 = mass::kilograms::to_carats(0.1);
		assert_approx_eq!(500.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_carats_2() {
		let result: f64 = mass::kilograms::to_carats(0.08);
		assert_approx_eq!(400.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownkilograms_to_carats_3() {
		let result: f64 = mass::kilograms::to_carats(2.0);
		assert_approx_eq!(10000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_grams_1() {
		let result: f64 = mass::milligrams::to_grams(190.0);
		assert_approx_eq!(0.19, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_grams_2() {
		let result: f64 = mass::milligrams::to_grams(2300.0);
		assert_approx_eq!(2.3, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_grams_3() {
		let result: f64 = mass::milligrams::to_grams(19000.0);
		assert_approx_eq!(19.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_kilograms_1() {
		let result: f64 = mass::milligrams::to_kilograms(1234567.0);
		assert_approx_eq!(1.234567, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_kilograms_2() {
		let result: f64 = mass::milligrams::to_kilograms(900800.0);
		assert_approx_eq!(0.9008, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_kilograms_3() {
		let result: f64 = mass::milligrams::to_kilograms(7800000.0);
		assert_approx_eq!(7.8, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_tonnes_1() {
		let result: f64 = mass::milligrams::to_tonnes(900000000.0);
		assert_approx_eq!(0.9, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_tonnes_2() {
		let result: f64 = mass::milligrams::to_tonnes(60000000.0);
		assert_approx_eq!(0.06, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_tonnes_3() {
		let result: f64 = mass::milligrams::to_tonnes(123456789.0);
		assert_approx_eq!(0.123456789, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_ounces_1() {
		let result: f64 = mass::milligrams::to_ounces(6000.0);
		assert_approx_eq!(0.2116438, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_ounces_2() {
		let result: f64 = mass::milligrams::to_ounces(123456.0);
		assert_approx_eq!(4.35478225, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_ounces_3() {
		let result: f64 = mass::milligrams::to_ounces(8001.0);
		assert_approx_eq!(0.282227, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_pounds_1() {
		let result: f64 = mass::milligrams::to_pounds(123456.0);
		assert_approx_eq!(0.27217389, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_pounds_2() {
		let result: f64 = mass::milligrams::to_pounds(800900.0);
		assert_approx_eq!(1.76568226, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_pounds_3() {
		let result: f64 = mass::milligrams::to_pounds(666666.0);
		assert_approx_eq!(1.46974694, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_stones_1() {
		let result: f64 = mass::milligrams::to_stones(900000.0);
		assert_approx_eq!(0.14172574, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_stones_2() {
		let result: f64 = mass::milligrams::to_stones(12345678.0);
		assert_approx_eq!(1.9441115001, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_stones_3() {
		let result: f64 = mass::milligrams::to_stones(800100.0);
		assert_approx_eq!(0.125994183, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_carats_1() {
		let result: f64 = mass::milligrams::to_carats(600.0);
		assert_approx_eq!(3.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_carats_2() {
		let result: f64 = mass::milligrams::to_carats(1234.0);
		assert_approx_eq!(6.17, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownmilligrams_to_carats_3() {
		let result: f64 = mass::milligrams::to_carats(9090.0);
		assert_approx_eq!(45.45, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_milligrams_1() {
		let result: f64 = mass::ounces::to_milligrams(0.2);
		assert_approx_eq!(5669.9, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_milligrams_2() {
		let result: f64 = mass::ounces::to_milligrams(12.0);
		assert_approx_eq!(340194.2772, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_milligrams_3() {
		let result: f64 = mass::ounces::to_milligrams(1.8);
		assert_approx_eq!(51029.141579, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_grams_1() {
		let result: f64 = mass::ounces::to_grams(2.0);
		assert_approx_eq!(56.699, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_grams_2() {
		let result: f64 = mass::ounces::to_grams(0.3);
		assert_approx_eq!(8.50486, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_grams_3() {
		let result: f64 = mass::ounces::to_grams(7.0);
		assert_approx_eq!(198.447, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_kilograms_1() {
		let result: f64 = mass::ounces::to_kilograms(56.0);
		assert_approx_eq!(1.58757, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_kilograms_2() {
		let result: f64 = mass::ounces::to_kilograms(123.0);
		assert_approx_eq!(3.48699, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_kilograms_3() {
		let result: f64 = mass::ounces::to_kilograms(100.9);
		assert_approx_eq!(2.8604669, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_tonnes_1() {
		let result: f64 = mass::ounces::to_tonnes(8000.0);
		assert_approx_eq!(0.2267962, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_tonnes_2() {
		let result: f64 = mass::ounces::to_tonnes(1234567.0);
		assert_approx_eq!(34.99938572, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_tonnes_3() {
		let result: f64 = mass::ounces::to_tonnes(900800.0);
		assert_approx_eq!(25.5372504, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_pounds_1() {
		let result: f64 = mass::ounces::to_pounds(90.0);
		assert_approx_eq!(5.625, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_pounds_2() {
		let result: f64 = mass::ounces::to_pounds(5.2);
		assert_approx_eq!(0.325, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_pounds_3() {
		let result: f64 = mass::ounces::to_pounds(12.0);
		assert_approx_eq!(0.75, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_stones_1() {
		let result: f64 = mass::ounces::to_stones(167.0);
		assert_approx_eq!(0.745536, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_stones_2() {
		let result: f64 = mass::ounces::to_stones(800.7);
		assert_approx_eq!(3.5745536, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_stones_3() {
		let result: f64 = mass::ounces::to_stones(1234.5);
		assert_approx_eq!(5.51116071, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_carats_1() {
		let result: f64 = mass::ounces::to_carats(0.0012);
		assert_approx_eq!(0.170097139, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_carats_2() {
		let result: f64 = mass::ounces::to_carats(4.0);
		assert_approx_eq!(566.99, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownounces_to_carats_3() {
		let result: f64 = mass::ounces::to_carats(1.4);
		assert_approx_eq!(198.447, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_milligrams_1() {
		let result: f64 = mass::pounds::to_milligrams(2.2);
		assert_approx_eq!(997903.214, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_milligrams_2() {
		let result: f64 = mass::pounds::to_milligrams(0.7);
		assert_approx_eq!(317514.6589, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_milligrams_3() {
		let result: f64 = mass::pounds::to_milligrams(0.32);
		assert_approx_eq!(145149.5584, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_grams_1() {
		let result: f64 = mass::pounds::to_grams(0.3);
		assert_approx_eq!(136.078, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_grams_2() {
		let result: f64 = mass::pounds::to_grams(1.2);
		assert_approx_eq!(544.311, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_grams_3() {
		let result: f64 = mass::pounds::to_grams(9.0);
		assert_approx_eq!(4082.33, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_kilograms_1() {
		let result: f64 = mass::pounds::to_kilograms(5.0);
		assert_approx_eq!(2.26796, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_kilograms_2() {
		let result: f64 = mass::pounds::to_kilograms(1.1);
		assert_approx_eq!(0.498952, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_kilograms_3() {
		let result: f64 = mass::pounds::to_kilograms(0.7);
		assert_approx_eq!(0.317515, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_tonnes_1() {
		let result: f64 = mass::pounds::to_tonnes(1233.0);
		assert_approx_eq!(0.5592794, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_tonnes_2() {
		let result: f64 = mass::pounds::to_tonnes(656565.0);
		assert_approx_eq!(297.812874, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_tonnes_3() {
		let result: f64 = mass::pounds::to_tonnes(900.0);
		assert_approx_eq!(0.408233, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_ounces_1() {
		let result: f64 = mass::pounds::to_ounces(45.0);
		assert_approx_eq!(720.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_ounces_2() {
		let result: f64 = mass::pounds::to_ounces(6.7);
		assert_approx_eq!(107.2, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_ounces_3() {
		let result: f64 = mass::pounds::to_ounces(89.1);
		assert_approx_eq!(1425.6, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_stones_1() {
		let result: f64 = mass::pounds::to_stones(89.1);
		assert_approx_eq!(6.364286, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_stones_2() {
		let result: f64 = mass::pounds::to_stones(1.2);
		assert_approx_eq!(0.0857143, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_stones_3() {
		let result: f64 = mass::pounds::to_stones(789.0);
		assert_approx_eq!(56.3571, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_carats_1() {
		let result: f64 = mass::pounds::to_carats(80.0);
		assert_approx_eq!(181436.7522, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_carats_2() {
		let result: f64 = mass::pounds::to_carats(2.34);
		assert_approx_eq!(5307.031, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownpounds_to_carats_3() {
		let result: f64 = mass::pounds::to_carats(0.9);
		assert_approx_eq!(2041.17, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_milligrams_1() {
		let result: f64 = mass::stones::to_milligrams(0.009);
		assert_approx_eq!(57152.63861, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_milligrams_2() {
		let result: f64 = mass::stones::to_milligrams(0.002);
		assert_approx_eq!(12700.586, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_milligrams_3() {
		let result: f64 = mass::stones::to_milligrams(0.0006);
		assert_approx_eq!(3810.17591, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_grams_1() {
		let result: f64 = mass::stones::to_grams(1.2);
		assert_approx_eq!(7620.35, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_grams_2() {
		let result: f64 = mass::stones::to_grams(8.0);
		assert_approx_eq!(50802.34543, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_grams_3() {
		let result: f64 = mass::stones::to_grams(90.0);
		assert_approx_eq!(571526.38619, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_kilograms_1() {
		let result: f64 = mass::stones::to_kilograms(90.0);
		assert_approx_eq!(571.526, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_kilograms_2() {
		let result: f64 = mass::stones::to_kilograms(3.4);
		assert_approx_eq!(21.591, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_kilograms_3() {
		let result: f64 = mass::stones::to_kilograms(66.0);
		assert_approx_eq!(419.119, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_tonnes_1() {
		let result: f64 = mass::stones::to_tonnes(100.0);
		assert_approx_eq!(0.635029, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_tonnes_2() {
		let result: f64 = mass::stones::to_tonnes(12345.0);
		assert_approx_eq!(78.394369, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_tonnes_3() {
		let result: f64 = mass::stones::to_tonnes(10099.0);
		assert_approx_eq!(64.131611, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_ounces_1() {
		let result: f64 = mass::stones::to_ounces(34.0);
		assert_approx_eq!(7616.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_ounces_2() {
		let result: f64 = mass::stones::to_ounces(1.2);
		assert_approx_eq!(268.8, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_ounces_3() {
		let result: f64 = mass::stones::to_ounces(800.0);
		assert_approx_eq!(179200.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_pounds_1() {
		let result: f64 = mass::stones::to_pounds(800.0);
		assert_approx_eq!(11200.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_pounds_2() {
		let result: f64 = mass::stones::to_pounds(0.5);
		assert_approx_eq!(7.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_pounds_3() {
		let result: f64 = mass::stones::to_pounds(52.1);
		assert_approx_eq!(729.4, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_carats_1() {
		let result: f64 = mass::stones::to_carats(0.01);
		assert_approx_eq!(317.5147, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_carats_2() {
		let result: f64 = mass::stones::to_carats(0.006);
		assert_approx_eq!(190.5088, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knownstones_to_carats_3() {
		let result: f64 = mass::stones::to_carats(2.1);
		assert_approx_eq!(66677.25, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_milligrams_1() {
		let result: f64 = mass::tonnes::to_milligrams(0.009);
		assert_approx_eq!(9000000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_milligrams_2() {
		let result: f64 = mass::tonnes::to_milligrams(0.00081);
		assert_approx_eq!(810000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_milligrams_3() {
		let result: f64 = mass::tonnes::to_milligrams(0.00123);
		assert_approx_eq!(1230000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_grams_1() {
		let result: f64 = mass::tonnes::to_grams(0.00123);
		assert_approx_eq!(1230.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_grams_2() {
		let result: f64 = mass::tonnes::to_grams(0.8);
		assert_approx_eq!(800000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_grams_3() {
		let result: f64 = mass::tonnes::to_grams(0.03);
		assert_approx_eq!(30000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_kilograms_1() {
		let result: f64 = mass::tonnes::to_kilograms(0.03);
		assert_approx_eq!(30.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_kilograms_2() {
		let result: f64 = mass::tonnes::to_kilograms(4.0);
		assert_approx_eq!(4000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_kilograms_3() {
		let result: f64 = mass::tonnes::to_kilograms(1.2);
		assert_approx_eq!(1200.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_ounces_1() {
		let result: f64 = mass::tonnes::to_ounces(1.2);
		assert_approx_eq!(42328.754376824065, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_ounces_2() {
		let result: f64 = mass::tonnes::to_ounces(0.8);
		assert_approx_eq!(28219.169584549378, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_ounces_3() {
		let result: f64 = mass::tonnes::to_ounces(0.001);
		assert_approx_eq!(35.273962, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_pounds_1() {
		let result: f64 = mass::tonnes::to_pounds(1.2);
		assert_approx_eq!(2645.55, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_pounds_2() {
		let result: f64 = mass::tonnes::to_pounds(0.9);
		assert_approx_eq!(1984.16, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_pounds_3() {
		let result: f64 = mass::tonnes::to_pounds(34.0);
		assert_approx_eq!(74957.08, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_stones_1() {
		let result: f64 = mass::tonnes::to_stones(12.0);
		assert_approx_eq!(1889.68, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_stones_2() {
		let result: f64 = mass::tonnes::to_stones(8.4);
		assert_approx_eq!(1322.77, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_stones_3() {
		let result: f64 = mass::tonnes::to_stones(0.3);
		assert_approx_eq!(47.2419, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_carats_1() {
		let result: f64 = mass::tonnes::to_carats(0.003);
		assert_approx_eq!(15000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_carats_2() {
		let result: f64 = mass::tonnes::to_carats(0.09);
		assert_approx_eq!(450000.0, result, 0.01);
	}

	/// Need to convert to parameterized tests
	#[test]
	fn it_convert_knowntonnes_to_carats_3() {
		let result: f64 = mass::tonnes::to_carats(0.0012);
		assert_approx_eq!(6000.0, result, 0.01);
	}

}