simplify tests, handle coef errors

Author: dkuku

native/explorer/src/datatypes.rs

@@ -629,13 +629,17 @@ impl ExDecimal {
         }
     }
 
-    pub fn signed_coef(self) -> i128 {
+    pub fn signed_coef(self) -> Result<i128, ExplorerError> {
         let base = self.sign as i128 * self.coef;
         if self.exp > 0 {
             base.checked_mul(10_i128.pow(self.exp as u32))
-                .expect("coefficient overflow")
+                .ok_or_else(|| {
+                    ExplorerError::Other(
+                        "cannot decode a valid decimal from term; check that `coef` fits into an `i128`. error: throw(<term>)".to_string()
+                    )
+                })
         } else {
-            base
+            Ok(base)
         }
     }
 
@@ -653,7 +657,7 @@ impl ExDecimal {
 
 impl Literal for ExDecimal {
     fn lit(self) -> Expr {
-        let coef = self.signed_coef();
+        let coef = self.signed_coef().unwrap();
         let scale = self.scale();
 
         Expr::Literal(LiteralValue::Scalar(Scalar::new(
@@ -721,6 +725,7 @@ impl<'a> rustler::Decoder<'a> for ExValidValue<'a> {
                 } else if let Ok(duration) = term.decode::<ExDuration>() {
                     Ok(ExValidValue::Duration(duration))
                 } else if let Ok(decimal) = term.decode::<ExDecimal>() {
+                    decimal.signed_coef().map_err(|_| rustler::Error::BadArg)?;
                     Ok(ExValidValue::Decimal(decimal))
                 } else {
                     Err(rustler::Error::BadArg)

native/explorer/src/series/from_list.rs

@@ -240,14 +240,16 @@ pub fn s_from_list_decimal(
                     })
             }
 
-            TermType::Map => item
-                .decode::<ExDecimal>()
-                .map(|ex_decimal| AnyValue::Decimal(ex_decimal.signed_coef(), ex_decimal.scale()))
-                .map_err(|error| {
-                    ExplorerError::Other(format!(
+            TermType::Map => {
+                match item.decode::<ExDecimal>() {
+                    Ok(ex_decimal) => ex_decimal
+                        .signed_coef()
+                        .map(|coef| AnyValue::Decimal(coef, ex_decimal.scale())),
+                    Err(error) => Err(ExplorerError::Other(format!(
                         "cannot decode a valid decimal from term; check that `coef` fits into an `i128`. error: {error:?}"
-                    ))
-                }),
+                    ))),
+                }
+            }
             TermType::Atom => Ok(AnyValue::Null),
 
             TermType::Float => item

test/explorer/series_test.exs

@@ -1998,64 +1998,37 @@ defmodule Explorer.SeriesTest do
       assert Series.to_list(s3) === [Decimal.new("2.2"), Decimal.new("4.0"), Decimal.new("6.1")]
     end
 
-    test "adding decimal series with scientific notation" do
-      # Test positive values with positive exponents
-      s1 = Series.from_list([Decimal.new("2.1e10"), Decimal.new("3.5e10"), Decimal.new("1.0e10")])
-      s2 = Series.from_list([Decimal.new("1.0e10"), Decimal.new("2.0e10"), Decimal.new("3.0e10")])
-
-      s3 = Series.add(s1, s2)
-      [v1, v2, v3] = Series.to_list(s3)
-
-      assert Decimal.eq?(v1, Decimal.new("3.1e10"))
-      assert Decimal.eq?(v2, Decimal.new("5.5e10"))
-      assert Decimal.eq?(v3, Decimal.new("4.0e10"))
-
-      # Test negative values with positive exponents
-      s4 =
-        Series.from_list([Decimal.new("-2.1e10"), Decimal.new("-3.5e10"), Decimal.new("-1.0e10")])
-
-      s5 = Series.from_list([Decimal.new("1.0e10"), Decimal.new("2.0e10"), Decimal.new("3.0e10")])
-
-      s6 = Series.add(s4, s5)
-      [v4, v5, v6] = Series.to_list(s6)
-
-      assert Decimal.eq?(v4, Decimal.new("-1.1e10"))
-      assert Decimal.eq?(v5, Decimal.new("-1.5e10"))
-      assert Decimal.eq?(v6, Decimal.new("2.0e10"))
-
-      # Test mixed negative and positive values
-      s7 =
-        Series.from_list([Decimal.new("-2.1e10"), Decimal.new("3.5e10"), Decimal.new("-1.0e10")])
-
-      s8 =
-        Series.from_list([Decimal.new("-1.0e10"), Decimal.new("-2.0e10"), Decimal.new("3.0e10")])
-
-      s9 = Series.add(s7, s8)
-      [v7, v8, v9] = Series.to_list(s9)
-
-      assert Decimal.eq?(v7, Decimal.new("-3.1e10"))
-      assert Decimal.eq?(v8, Decimal.new("1.5e10"))
-      assert Decimal.eq?(v9, Decimal.new("2.0e10"))
-    end
+    test "adding decimal series with positive and negative exponents" do
+      s1 =
+        Series.from_list([
+          Decimal.new("2.1e20"),
+          Decimal.new("-3.5e10"),
+          Decimal.new("1.5e-15"),
+          Decimal.new("1.0e2")
+        ])
 
-    test "adding decimal series with maximum safe values" do
-      # Test maximum safe values in both scientific and normal notation
-      # Max safe is around 1e27 for i128 (< 2^127 ≈ 1.7e38)
-      s1 = Series.from_list([Decimal.new("1.0e27"), Decimal.new("1000000000000000000000000000")])
-      s2 = Series.from_list([Decimal.new("2.0e27"), Decimal.new("2000000000000000000000000000")])
+      s2 =
+        Series.from_list([
+          Decimal.new("1.0e20"),
+          Decimal.new("2.0e10"),
+          Decimal.new("2.5e-15"),
+          Decimal.new("5.0e-2")
+        ])
 
       s3 = Series.add(s1, s2)
-      [v1, v2] = Series.to_list(s3)
+      [v1, v2, v3, v4] = Series.to_list(s3)
 
-      assert Decimal.eq?(v1, Decimal.new("3.0e27"))
-      assert Decimal.eq?(v2, Decimal.new("3000000000000000000000000000"))
+      assert Decimal.eq?(v1, Decimal.new("3.1e20"))
+      assert Decimal.eq?(v2, Decimal.new("-1.5e10"))
+      assert Decimal.eq?(v3, Decimal.new("4.0e-15"))
+      assert Decimal.eq?(v4, Decimal.new("100.05"))
     end
 
     test "overflow with values exceeding i128 limits" do
-      # This should fail: 3.4e38 exceeds i128 max (2^127 - 1 ≈ 1.7e38)
-      assert_raise ErlangError, fn ->
-        Series.from_list([Decimal.new("3.4e38")])
-      end
+      assert_raise RuntimeError,
+                   "Generic Error: cannot decode a valid decimal from term;" <>
+                     " check that `coef` fits into an `i128`. error: throw(<term>)",
+                   fn -> Series.from_list([Decimal.new("3.4e38")]) end
     end
   end