test(lazer): add more Price and Rate tests

Author: Riateche

lazer/sdk/rust/protocol/src/lib.rs

@@ -69,8 +69,11 @@ pub enum PriceFeedProperty {
     // More fields may be added later.
 }
 
+// Operation and coefficient for converting value to mantissa.
 enum ExponentFactor {
+    // mantissa = value * factor
     Mul(i64),
+    // mantissa = value / factor
     Div(i64),
 }
 

lazer/sdk/rust/protocol/src/price/tests.rs

@@ -20,7 +20,7 @@ fn price_constructs() {
 }
 
 #[test]
-fn price_constructs_negative_mantissa() {
+fn price_constructs_with_negative_mantissa() {
     let price = Price::parse_str("-42.68", -8).unwrap();
     assert_eq!(price.0.get(), -4_268_000_000);
     assert_float_absolute_eq!(price.to_f64(-8).unwrap(), -42.68);
@@ -39,7 +39,7 @@ fn price_constructs_negative_mantissa() {
 }
 
 #[test]
-fn price_constructs_zero_exponent() {
+fn price_constructs_with_zero_exponent() {
     let price = Price::parse_str("42", 0).unwrap();
     assert_eq!(price.0.get(), 42);
     assert_float_absolute_eq!(price.to_f64(0).unwrap(), 42.);
@@ -57,19 +57,46 @@ fn price_constructs_zero_exponent() {
     assert_float_absolute_eq!(price4.to_f64(0).unwrap(), 42.);
 }
 
+#[test]
+fn price_constructs_with_positive_exponent() {
+    let price = Price::parse_str("42_680_000", 3).unwrap();
+    assert_eq!(price.0.get(), 42_680);
+    assert_float_absolute_eq!(price.to_f64(3).unwrap(), 42_680_000.);
+
+    let price2 = Price::from_integer(200_000, 3).unwrap();
+    assert_eq!(price2.0.get(), 200);
+    assert_float_absolute_eq!(price2.to_f64(3).unwrap(), 200_000.);
+
+    let price3 = Price::from_mantissa(123_456).unwrap();
+    assert_eq!(price3.0.get(), 123_456);
+    assert_float_absolute_eq!(price3.to_f64(3).unwrap(), 123_456_000.);
+
+    let price4 = Price::from_f64(42_680_000., 3).unwrap();
+    assert_eq!(price4.0.get(), 42_680);
+    assert_float_absolute_eq!(price4.to_f64(3).unwrap(), 42_680_000.);
+}
+
 #[test]
 fn price_rejects_zero_mantissa() {
     Price::parse_str("0.0", -8).unwrap_err();
     Price::from_integer(0, -8).unwrap_err();
     Price::from_mantissa(0).unwrap_err();
     Price::from_f64(-0.0, -8).unwrap_err();
+
+    Price::parse_str("0.0", 8).unwrap_err();
+    Price::from_integer(0, 8).unwrap_err();
+    Price::from_f64(-0.0, 8).unwrap_err();
 }
 
 #[test]
 fn price_rejects_too_precise() {
     Price::parse_str("42.68", 0).unwrap_err();
     Price::parse_str("42.68", -1).unwrap_err();
     Price::parse_str("42.68", -2).unwrap();
+
+    Price::parse_str("42_680", 3).unwrap_err();
+    Price::parse_str("42_600", 3).unwrap_err();
+    Price::parse_str("42_000", 3).unwrap();
 }
 
 #[test]
@@ -84,6 +111,14 @@ fn price_ops() {
             .unwrap(),
         12.34 + 23.45
     );
+    assert_float_absolute_eq!(
+        price1
+            .sub_with_same_mantissa(price2)
+            .unwrap()
+            .to_f64(-8)
+            .unwrap(),
+        12.34 - 23.45
+    );
     assert_float_absolute_eq!(
         price1.mul_integer(2).unwrap().to_f64(-8).unwrap(),
         12.34 * 2.
@@ -97,4 +132,18 @@ fn price_ops() {
         price1.mul_decimal(3456, -2).unwrap().to_f64(-8).unwrap(),
         12.34 * 34.56
     );
+
+    let price2 = Price::parse_str("42_000", 3).unwrap();
+    assert_float_absolute_eq!(
+        price2.mul_integer(2).unwrap().to_f64(3).unwrap(),
+        42_000. * 2.
+    );
+    assert_float_absolute_eq!(
+        price2.div_integer(2).unwrap().to_f64(3).unwrap(),
+        42_000. / 2.
+    );
+    assert_float_absolute_eq!(
+        price2.mul_decimal(3456, -2).unwrap().to_f64(3).unwrap(),
+        (42_000_f64 * 34.56 / 1000.).floor() * 1000.
+    );
 }

lazer/sdk/rust/protocol/src/rate/tests.rs

@@ -20,7 +20,7 @@ fn rate_constructs() {
 }
 
 #[test]
-fn rate_constructs_negative_mantissa() {
+fn rate_constructs_with_negative_mantissa() {
     let rate = Rate::parse_str("-42.68", -8).unwrap();
     assert_eq!(rate.0, -4_268_000_000);
     assert_float_absolute_eq!(rate.to_f64(-8).unwrap(), -42.68);
@@ -39,7 +39,7 @@ fn rate_constructs_negative_mantissa() {
 }
 
 #[test]
-fn rate_constructs_zero_exponent() {
+fn rate_constructs_with_zero_exponent() {
     let rate = Rate::parse_str("42", 0).unwrap();
     assert_eq!(rate.0, 42);
     assert_float_absolute_eq!(rate.to_f64(0).unwrap(), 42.);
@@ -58,7 +58,7 @@ fn rate_constructs_zero_exponent() {
 }
 
 #[test]
-fn rate_constructs_zero_mantissa() {
+fn rate_constructs_with_zero_mantissa() {
     let rate1 = Rate::parse_str("0.0", -8).unwrap();
     assert_eq!(rate1.0, 0);
     let rate2 = Rate::from_integer(0, -8).unwrap();
@@ -67,11 +67,41 @@ fn rate_constructs_zero_mantissa() {
     assert_eq!(rate3.0, 0);
     let rate4 = Rate::from_f64(-0.0, -8).unwrap();
     assert_eq!(rate4.0, 0);
+
+    let rate1 = Rate::parse_str("0.0", 8).unwrap();
+    assert_eq!(rate1.0, 0);
+    let rate2 = Rate::from_integer(0, 8).unwrap();
+    assert_eq!(rate2.0, 0);
+    let rate4 = Rate::from_f64(-0.0, 8).unwrap();
+    assert_eq!(rate4.0, 0);
+}
+
+#[test]
+fn rate_constructs_with_positive_exponent() {
+    let rate = Rate::parse_str("42_680_000", 3).unwrap();
+    assert_eq!(rate.0, 42_680);
+    assert_float_absolute_eq!(rate.to_f64(3).unwrap(), 42_680_000.);
+
+    let rate2 = Rate::from_integer(200_000, 3).unwrap();
+    assert_eq!(rate2.0, 200);
+    assert_float_absolute_eq!(rate2.to_f64(3).unwrap(), 200_000.);
+
+    let rate3 = Rate::from_mantissa(123_456);
+    assert_eq!(rate3.0, 123_456);
+    assert_float_absolute_eq!(rate3.to_f64(3).unwrap(), 123_456_000.);
+
+    let rate4 = Rate::from_f64(42_680_000., 3).unwrap();
+    assert_eq!(rate4.0, 42_680);
+    assert_float_absolute_eq!(rate4.to_f64(3).unwrap(), 42_680_000.);
 }
 
 #[test]
 fn rate_rejects_too_precise() {
     Rate::parse_str("42.68", 0).unwrap_err();
     Rate::parse_str("42.68", -1).unwrap_err();
     Rate::parse_str("42.68", -2).unwrap();
+
+    Rate::parse_str("42_680", 3).unwrap_err();
+    Rate::parse_str("42_600", 3).unwrap_err();
+    Rate::parse_str("42_000", 3).unwrap();
 }