From aa616c470091175500d8de048f87d980972b25df Mon Sep 17 00:00:00 2001
From: Franco Barpp Gomes <franco@nethermind.io>
Date: Sun, 14 Jan 2024 16:43:30 -0300
Subject: [PATCH] Replace eq asserts with assert_eq! macros

---
 src/math/src/tests/math_test.cairo | 372 ++++++++++++-----------------
 1 file changed, 157 insertions(+), 215 deletions(-)

diff --git a/src/math/src/tests/math_test.cairo b/src/math/src/tests/math_test.cairo
index ea866a9c..1860cc8f 100644
--- a/src/math/src/tests/math_test.cairo
+++ b/src/math/src/tests/math_test.cairo
@@ -227,238 +227,180 @@ fn test_rotr_max() {
 
 #[test]
 fn test_wrapping_math_non_wrapping() {
-    assert(10_u8.wrapping_add(10_u8) == 20_u8, 'invalid result');
-    assert(0_u8.wrapping_add(10_u8) == 10_u8, 'invalid result');
-    assert(10_u8.wrapping_add(0_u8) == 10_u8, 'invalid result');
-    assert(0_u8.wrapping_add(0_u8) == 0_u8, 'invalid result');
-    assert(20_u8.wrapping_sub(10_u8) == 10_u8, 'invalid result');
-    assert(10_u8.wrapping_sub(0_u8) == 10_u8, 'invalid result');
-    assert(0_u8.wrapping_sub(0_u8) == 0_u8, 'invalid result');
-    assert(10_u8.wrapping_mul(10_u8) == 100_u8, 'invalid result');
-    assert(10_u8.wrapping_mul(0_u8) == 0_u8, 'invalid result');
-    assert(0_u8.wrapping_mul(10_u8) == 0_u8, 'invalid result');
-    assert(0_u8.wrapping_mul(0_u8) == 0_u8, 'invalid result');
+    assert_eq!(10_u8.wrapping_add(10_u8), 20_u8);
+    assert_eq!(0_u8.wrapping_add(10_u8), 10_u8);
+    assert_eq!(10_u8.wrapping_add(0_u8), 10_u8);
+    assert_eq!(0_u8.wrapping_add(0_u8), 0_u8);
+    assert_eq!(20_u8.wrapping_sub(10_u8), 10_u8);
+    assert_eq!(10_u8.wrapping_sub(0_u8), 10_u8);
+    assert_eq!(0_u8.wrapping_sub(0_u8), 0_u8);
+    assert_eq!(10_u8.wrapping_mul(10_u8), 100_u8);
+    assert_eq!(10_u8.wrapping_mul(0_u8), 0_u8);
+    assert_eq!(0_u8.wrapping_mul(10_u8), 0_u8);
+    assert_eq!(0_u8.wrapping_mul(0_u8), 0_u8);
 
-    assert(10_u16.wrapping_add(10_u16) == 20_u16, 'invalid result');
-    assert(0_u16.wrapping_add(10_u16) == 10_u16, 'invalid result');
-    assert(10_u16.wrapping_add(0_u16) == 10_u16, 'invalid result');
-    assert(0_u16.wrapping_add(0_u16) == 0_u16, 'invalid result');
-    assert(20_u16.wrapping_sub(10_u16) == 10_u16, 'invalid result');
-    assert(10_u16.wrapping_sub(0_u16) == 10_u16, 'invalid result');
-    assert(0_u16.wrapping_sub(0_u16) == 0_u16, 'invalid result');
-    assert(10_u16.wrapping_mul(10_u16) == 100_u16, 'invalid result');
-    assert(10_u16.wrapping_mul(0_u16) == 0_u16, 'invalid result');
-    assert(0_u16.wrapping_mul(10_u16) == 0_u16, 'invalid result');
-    assert(0_u16.wrapping_mul(0_u16) == 0_u16, 'invalid result');
+    assert_eq!(10_u16.wrapping_add(10_u16), 20_u16);
+    assert_eq!(0_u16.wrapping_add(10_u16), 10_u16);
+    assert_eq!(10_u16.wrapping_add(0_u16), 10_u16);
+    assert_eq!(0_u16.wrapping_add(0_u16), 0_u16);
+    assert_eq!(20_u16.wrapping_sub(10_u16), 10_u16);
+    assert_eq!(10_u16.wrapping_sub(0_u16), 10_u16);
+    assert_eq!(0_u16.wrapping_sub(0_u16), 0_u16);
+    assert_eq!(10_u16.wrapping_mul(10_u16), 100_u16);
+    assert_eq!(10_u16.wrapping_mul(0_u16), 0_u16);
+    assert_eq!(0_u16.wrapping_mul(10_u16), 0_u16);
+    assert_eq!(0_u16.wrapping_mul(0_u16), 0_u16);
 
-    assert(10_u32.wrapping_add(10_u32) == 20_u32, 'invalid result');
-    assert(0_u32.wrapping_add(10_u32) == 10_u32, 'invalid result');
-    assert(10_u32.wrapping_add(0_u32) == 10_u32, 'invalid result');
-    assert(0_u32.wrapping_add(0_u32) == 0_u32, 'invalid result');
-    assert(20_u32.wrapping_sub(10_u32) == 10_u32, 'invalid result');
-    assert(10_u32.wrapping_sub(0_u32) == 10_u32, 'invalid result');
-    assert(0_u32.wrapping_sub(0_u32) == 0_u32, 'invalid result');
-    assert(10_u32.wrapping_mul(10_u32) == 100_u32, 'invalid result');
-    assert(10_u32.wrapping_mul(0_u32) == 0_u32, 'invalid result');
-    assert(0_u32.wrapping_mul(10_u32) == 0_u32, 'invalid result');
-    assert(0_u32.wrapping_mul(0_u32) == 0_u32, 'invalid result');
+    assert_eq!(10_u32.wrapping_add(10_u32), 20_u32);
+    assert_eq!(0_u32.wrapping_add(10_u32), 10_u32);
+    assert_eq!(10_u32.wrapping_add(0_u32), 10_u32);
+    assert_eq!(0_u32.wrapping_add(0_u32), 0_u32);
+    assert_eq!(20_u32.wrapping_sub(10_u32), 10_u32);
+    assert_eq!(10_u32.wrapping_sub(0_u32), 10_u32);
+    assert_eq!(0_u32.wrapping_sub(0_u32), 0_u32);
+    assert_eq!(10_u32.wrapping_mul(10_u32), 100_u32);
+    assert_eq!(10_u32.wrapping_mul(0_u32), 0_u32);
+    assert_eq!(0_u32.wrapping_mul(10_u32), 0_u32);
+    assert_eq!(0_u32.wrapping_mul(0_u32), 0_u32);
 
-    assert(10_u64.wrapping_add(10_u64) == 20_u64, 'invalid result');
-    assert(0_u64.wrapping_add(10_u64) == 10_u64, 'invalid result');
-    assert(10_u64.wrapping_add(0_u64) == 10_u64, 'invalid result');
-    assert(0_u64.wrapping_add(0_u64) == 0_u64, 'invalid result');
-    assert(20_u64.wrapping_sub(10_u64) == 10_u64, 'invalid result');
-    assert(10_u64.wrapping_sub(0_u64) == 10_u64, 'invalid result');
-    assert(0_u64.wrapping_sub(0_u64) == 0_u64, 'invalid result');
-    assert(10_u64.wrapping_mul(10_u64) == 100_u64, 'invalid result');
-    assert(10_u64.wrapping_mul(0_u64) == 0_u64, 'invalid result');
-    assert(0_u64.wrapping_mul(10_u64) == 0_u64, 'invalid result');
-    assert(0_u64.wrapping_mul(0_u64) == 0_u64, 'invalid result');
+    assert_eq!(10_u64.wrapping_add(10_u64), 20_u64);
+    assert_eq!(0_u64.wrapping_add(10_u64), 10_u64);
+    assert_eq!(10_u64.wrapping_add(0_u64), 10_u64);
+    assert_eq!(0_u64.wrapping_add(0_u64), 0_u64);
+    assert_eq!(20_u64.wrapping_sub(10_u64), 10_u64);
+    assert_eq!(10_u64.wrapping_sub(0_u64), 10_u64);
+    assert_eq!(0_u64.wrapping_sub(0_u64), 0_u64);
+    assert_eq!(10_u64.wrapping_mul(10_u64), 100_u64);
+    assert_eq!(10_u64.wrapping_mul(0_u64), 0_u64);
+    assert_eq!(0_u64.wrapping_mul(10_u64), 0_u64);
+    assert_eq!(0_u64.wrapping_mul(0_u64), 0_u64);
 
-    assert(10_u128.wrapping_add(10_u128) == 20_u128, 'invalid result');
-    assert(0_u128.wrapping_add(10_u128) == 10_u128, 'invalid result');
-    assert(10_u128.wrapping_add(0_u128) == 10_u128, 'invalid result');
-    assert(0_u128.wrapping_add(0_u128) == 0_u128, 'invalid result');
-    assert(20_u128.wrapping_sub(10_u128) == 10_u128, 'invalid result');
-    assert(10_u128.wrapping_sub(0_u128) == 10_u128, 'invalid result');
-    assert(0_u128.wrapping_sub(0_u128) == 0_u128, 'invalid result');
-    assert(10_u128.wrapping_mul(10_u128) == 100_u128, 'invalid result');
-    assert(10_u128.wrapping_mul(0_u128) == 0_u128, 'invalid result');
-    assert(0_u128.wrapping_mul(10_u128) == 0_u128, 'invalid result');
-    assert(0_u128.wrapping_mul(0_u128) == 0_u128, 'invalid result');
+    assert_eq!(10_u128.wrapping_add(10_u128), 20_u128);
+    assert_eq!(0_u128.wrapping_add(10_u128), 10_u128);
+    assert_eq!(10_u128.wrapping_add(0_u128), 10_u128);
+    assert_eq!(0_u128.wrapping_add(0_u128), 0_u128);
+    assert_eq!(20_u128.wrapping_sub(10_u128), 10_u128);
+    assert_eq!(10_u128.wrapping_sub(0_u128), 10_u128);
+    assert_eq!(0_u128.wrapping_sub(0_u128), 0_u128);
+    assert_eq!(10_u128.wrapping_mul(10_u128), 100_u128);
+    assert_eq!(10_u128.wrapping_mul(0_u128), 0_u128);
+    assert_eq!(0_u128.wrapping_mul(10_u128), 0_u128);
+    assert_eq!(0_u128.wrapping_mul(0_u128), 0_u128);
 
-    assert(10_u256.wrapping_add(10_u256) == 20_u256, 'invalid result');
-    assert(0_u256.wrapping_add(10_u256) == 10_u256, 'invalid result');
-    assert(10_u256.wrapping_add(0_u256) == 10_u256, 'invalid result');
-    assert(0_u256.wrapping_add(0_u256) == 0_u256, 'invalid result');
-    assert(20_u256.wrapping_sub(10_u256) == 10_u256, 'invalid result');
-    assert(10_u256.wrapping_sub(0_u256) == 10_u256, 'invalid result');
-    assert(0_u256.wrapping_sub(0_u256) == 0_u256, 'invalid result');
-    assert(10_u256.wrapping_mul(10_u256) == 100_u256, 'invalid result');
-    assert(10_u256.wrapping_mul(0_u256) == 0_u256, 'invalid result');
-    assert(0_u256.wrapping_mul(10_u256) == 0_u256, 'invalid result');
-    assert(0_u256.wrapping_mul(0_u256) == 0_u256, 'invalid result');
+    assert_eq!(10_u256.wrapping_add(10_u256), 20_u256);
+    assert_eq!(0_u256.wrapping_add(10_u256), 10_u256);
+    assert_eq!(10_u256.wrapping_add(0_u256), 10_u256);
+    assert_eq!(0_u256.wrapping_add(0_u256), 0_u256);
+    assert_eq!(20_u256.wrapping_sub(10_u256), 10_u256);
+    assert_eq!(10_u256.wrapping_sub(0_u256), 10_u256);
+    assert_eq!(0_u256.wrapping_sub(0_u256), 0_u256);
+    assert_eq!(10_u256.wrapping_mul(10_u256), 100_u256);
+    assert_eq!(10_u256.wrapping_mul(0_u256), 0_u256);
+    assert_eq!(0_u256.wrapping_mul(10_u256), 0_u256);
+    assert_eq!(0_u256.wrapping_mul(0_u256), 0_u256);
 }
 
 #[test]
 fn test_wrapping_math_wrapping() {
-    assert(BoundedInt::<u8>::max().wrapping_add(1_u8) == 0_u8, 'invalid result');
-    assert(1_u8.wrapping_add(BoundedInt::<u8>::max()) == 0_u8, 'invalid result');
-    assert(BoundedInt::<u8>::max().wrapping_add(2_u8) == 1_u8, 'invalid result');
-    assert(2_u8.wrapping_add(BoundedInt::<u8>::max()) == 1_u8, 'invalid result');
-    assert(
-        BoundedInt::<u8>::max().wrapping_add(BoundedInt::<u8>::max()) == BoundedInt::<u8>::max()
-            - 1_u8,
-        'invalid result'
-    );
-    assert(BoundedInt::<u8>::min().wrapping_sub(1_u8) == BoundedInt::<u8>::max(), 'invalid result');
-    assert(
-        BoundedInt::<u8>::min().wrapping_sub(2_u8) == BoundedInt::<u8>::max() - 1_u8,
-        'invalid result'
-    );
-    assert(1_u8.wrapping_sub(BoundedInt::<u8>::max()) == 2_u8, 'invalid result');
-    assert(0_u8.wrapping_sub(BoundedInt::<u8>::max()) == 1_u8, 'invalid result');
-    assert(BoundedInt::<u8>::max().wrapping_mul(BoundedInt::<u8>::max()) == 1_u8, 'invalid result');
-    assert(
-        (BoundedInt::<u8>::max() - 1_u8).wrapping_mul(2_u8) == BoundedInt::<u8>::max() - 3_u8,
-        'invalid result'
-    );
+    assert_eq!(BoundedInt::<u8>::max().wrapping_add(1_u8), 0_u8);
+    assert_eq!(1_u8.wrapping_add(BoundedInt::<u8>::max()), 0_u8);
+    assert_eq!(BoundedInt::<u8>::max().wrapping_add(2_u8), 1_u8);
+    assert_eq!(2_u8.wrapping_add(BoundedInt::<u8>::max()), 1_u8);
+    assert_eq!(
+        BoundedInt::<u8>::max().wrapping_add(BoundedInt::<u8>::max()),
+        BoundedInt::<u8>::max() - 1_u8
+    );
+    assert_eq!(BoundedInt::<u8>::min().wrapping_sub(1_u8), BoundedInt::<u8>::max());
+    assert_eq!(BoundedInt::<u8>::min().wrapping_sub(2_u8), BoundedInt::<u8>::max() - 1_u8);
+    assert_eq!(1_u8.wrapping_sub(BoundedInt::<u8>::max()), 2_u8);
+    assert_eq!(0_u8.wrapping_sub(BoundedInt::<u8>::max()), 1_u8);
+    assert_eq!(BoundedInt::<u8>::max().wrapping_mul(BoundedInt::<u8>::max()), 1_u8);
+    assert_eq!((BoundedInt::<u8>::max() - 1_u8).wrapping_mul(2_u8), BoundedInt::<u8>::max() - 3_u8);
 
-    assert(BoundedInt::<u16>::max().wrapping_add(1_u16) == 0_u16, 'invalid result');
-    assert(1_u16.wrapping_add(BoundedInt::<u16>::max()) == 0_u16, 'invalid result');
-    assert(BoundedInt::<u16>::max().wrapping_add(2_u16) == 1_u16, 'invalid result');
-    assert(2_u16.wrapping_add(BoundedInt::<u16>::max()) == 1_u16, 'invalid result');
-    assert(
-        BoundedInt::<u16>::max().wrapping_add(BoundedInt::<u16>::max()) == BoundedInt::<u16>::max()
-            - 1_u16,
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u16>::min().wrapping_sub(1_u16) == BoundedInt::<u16>::max(), 'invalid result'
-    );
-    assert(
-        BoundedInt::<u16>::min().wrapping_sub(2_u16) == BoundedInt::<u16>::max() - 1_u16,
-        'invalid result'
-    );
-    assert(1_u16.wrapping_sub(BoundedInt::<u16>::max()) == 2_u16, 'invalid result');
-    assert(0_u16.wrapping_sub(BoundedInt::<u16>::max()) == 1_u16, 'invalid result');
-    assert(
-        BoundedInt::<u16>::max().wrapping_mul(BoundedInt::<u16>::max()) == 1_u16, 'invalid result'
-    );
-    assert(
-        (BoundedInt::<u16>::max() - 1_u16).wrapping_mul(2_u16) == BoundedInt::<u16>::max() - 3_u16,
-        'invalid result'
+    assert_eq!(BoundedInt::<u16>::max().wrapping_add(1_u16), 0_u16);
+    assert_eq!(1_u16.wrapping_add(BoundedInt::<u16>::max()), 0_u16);
+    assert_eq!(BoundedInt::<u16>::max().wrapping_add(2_u16), 1_u16);
+    assert_eq!(2_u16.wrapping_add(BoundedInt::<u16>::max()), 1_u16);
+    assert_eq!(
+        BoundedInt::<u16>::max().wrapping_add(BoundedInt::<u16>::max()),
+        BoundedInt::<u16>::max() - 1_u16
+    );
+    assert_eq!(BoundedInt::<u16>::min().wrapping_sub(1_u16), BoundedInt::<u16>::max());
+    assert_eq!(BoundedInt::<u16>::min().wrapping_sub(2_u16), BoundedInt::<u16>::max() - 1_u16);
+    assert_eq!(1_u16.wrapping_sub(BoundedInt::<u16>::max()), 2_u16);
+    assert_eq!(0_u16.wrapping_sub(BoundedInt::<u16>::max()), 1_u16);
+    assert_eq!(BoundedInt::<u16>::max().wrapping_mul(BoundedInt::<u16>::max()), 1_u16);
+    assert_eq!(
+        (BoundedInt::<u16>::max() - 1_u16).wrapping_mul(2_u16), BoundedInt::<u16>::max() - 3_u16
     );
 
-    assert(BoundedInt::<u32>::max().wrapping_add(1_u32) == 0_u32, 'invalid result');
-    assert(1_u32.wrapping_add(BoundedInt::<u32>::max()) == 0_u32, 'invalid result');
-    assert(BoundedInt::<u32>::max().wrapping_add(2_u32) == 1_u32, 'invalid result');
-    assert(2_u32.wrapping_add(BoundedInt::<u32>::max()) == 1_u32, 'invalid result');
-    assert(
-        BoundedInt::<u32>::max().wrapping_add(BoundedInt::<u32>::max()) == BoundedInt::<u32>::max()
-            - 1_u32,
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u32>::min().wrapping_sub(1_u32) == BoundedInt::<u32>::max(), 'invalid result'
-    );
-    assert(
-        BoundedInt::<u32>::min().wrapping_sub(2_u32) == BoundedInt::<u32>::max() - 1_u32,
-        'invalid result'
-    );
-    assert(1_u32.wrapping_sub(BoundedInt::<u32>::max()) == 2_u32, 'invalid result');
-    assert(0_u32.wrapping_sub(BoundedInt::<u32>::max()) == 1_u32, 'invalid result');
-    assert(
-        BoundedInt::<u32>::max().wrapping_mul(BoundedInt::<u32>::max()) == 1_u32, 'invalid result'
-    );
-    assert(
-        (BoundedInt::<u32>::max() - 1_u32).wrapping_mul(2_u32) == BoundedInt::<u32>::max() - 3_u32,
-        'invalid result'
+    assert_eq!(BoundedInt::<u32>::max().wrapping_add(1_u32), 0_u32);
+    assert_eq!(1_u32.wrapping_add(BoundedInt::<u32>::max()), 0_u32);
+    assert_eq!(BoundedInt::<u32>::max().wrapping_add(2_u32), 1_u32);
+    assert_eq!(2_u32.wrapping_add(BoundedInt::<u32>::max()), 1_u32);
+    assert_eq!(
+        BoundedInt::<u32>::max().wrapping_add(BoundedInt::<u32>::max()),
+        BoundedInt::<u32>::max() - 1_u32
+    );
+    assert_eq!(BoundedInt::<u32>::min().wrapping_sub(1_u32), BoundedInt::<u32>::max());
+    assert_eq!(BoundedInt::<u32>::min().wrapping_sub(2_u32), BoundedInt::<u32>::max() - 1_u32);
+    assert_eq!(1_u32.wrapping_sub(BoundedInt::<u32>::max()), 2_u32);
+    assert_eq!(0_u32.wrapping_sub(BoundedInt::<u32>::max()), 1_u32);
+    assert_eq!(BoundedInt::<u32>::max().wrapping_mul(BoundedInt::<u32>::max()), 1_u32);
+    assert_eq!(
+        (BoundedInt::<u32>::max() - 1_u32).wrapping_mul(2_u32), BoundedInt::<u32>::max() - 3_u32
     );
 
-    assert(BoundedInt::<u64>::max().wrapping_add(1_u64) == 0_u64, 'invalid result');
-    assert(1_u64.wrapping_add(BoundedInt::<u64>::max()) == 0_u64, 'invalid result');
-    assert(BoundedInt::<u64>::max().wrapping_add(2_u64) == 1_u64, 'invalid result');
-    assert(2_u64.wrapping_add(BoundedInt::<u64>::max()) == 1_u64, 'invalid result');
-    assert(
-        BoundedInt::<u64>::max().wrapping_add(BoundedInt::<u64>::max()) == BoundedInt::<u64>::max()
-            - 1_u64,
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u64>::min().wrapping_sub(1_u64) == BoundedInt::<u64>::max(), 'invalid result'
-    );
-    assert(
-        BoundedInt::<u64>::min().wrapping_sub(2_u64) == BoundedInt::<u64>::max() - 1_u64,
-        'invalid result'
-    );
-    assert(1_u64.wrapping_sub(BoundedInt::<u64>::max()) == 2_u64, 'invalid result');
-    assert(0_u64.wrapping_sub(BoundedInt::<u64>::max()) == 1_u64, 'invalid result');
-    assert(
-        BoundedInt::<u64>::max().wrapping_mul(BoundedInt::<u64>::max()) == 1_u64, 'invalid result'
-    );
-    assert(
-        (BoundedInt::<u64>::max() - 1_u64).wrapping_mul(2_u64) == BoundedInt::<u64>::max() - 3_u64,
-        'invalid result'
+    assert_eq!(BoundedInt::<u64>::max().wrapping_add(1_u64), 0_u64);
+    assert_eq!(1_u64.wrapping_add(BoundedInt::<u64>::max()), 0_u64);
+    assert_eq!(BoundedInt::<u64>::max().wrapping_add(2_u64), 1_u64);
+    assert_eq!(2_u64.wrapping_add(BoundedInt::<u64>::max()), 1_u64);
+    assert_eq!(
+        BoundedInt::<u64>::max().wrapping_add(BoundedInt::<u64>::max()),
+        BoundedInt::<u64>::max() - 1_u64
+    );
+    assert_eq!(BoundedInt::<u64>::min().wrapping_sub(1_u64), BoundedInt::<u64>::max());
+    assert_eq!(BoundedInt::<u64>::min().wrapping_sub(2_u64), BoundedInt::<u64>::max() - 1_u64);
+    assert_eq!(1_u64.wrapping_sub(BoundedInt::<u64>::max()), 2_u64);
+    assert_eq!(0_u64.wrapping_sub(BoundedInt::<u64>::max()), 1_u64);
+    assert_eq!(BoundedInt::<u64>::max().wrapping_mul(BoundedInt::<u64>::max()), 1_u64);
+    assert_eq!(
+        (BoundedInt::<u64>::max() - 1_u64).wrapping_mul(2_u64), BoundedInt::<u64>::max() - 3_u64
     );
 
-    assert(BoundedInt::<u128>::max().wrapping_add(1_u128) == 0_u128, 'invalid result');
-    assert(1_u128.wrapping_add(BoundedInt::<u128>::max()) == 0_u128, 'invalid result');
-    assert(BoundedInt::<u128>::max().wrapping_add(2_u128) == 1_u128, 'invalid result');
-    assert(2_u128.wrapping_add(BoundedInt::<u128>::max()) == 1_u128, 'invalid result');
-    assert(
-        BoundedInt::<u128>::max()
-            .wrapping_add(BoundedInt::<u128>::max()) == BoundedInt::<u128>::max()
-            - 1_u128,
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u128>::min().wrapping_sub(1_u128) == BoundedInt::<u128>::max(),
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u128>::min().wrapping_sub(2_u128) == BoundedInt::<u128>::max() - 1_u128,
-        'invalid result'
-    );
-    assert(1_u128.wrapping_sub(BoundedInt::<u128>::max()) == 2_u128, 'invalid result');
-    assert(0_u128.wrapping_sub(BoundedInt::<u128>::max()) == 1_u128, 'invalid result');
-    assert(
-        BoundedInt::<u128>::max().wrapping_mul(BoundedInt::<u128>::max()) == 1_u128,
-        'invalid result'
-    );
-    assert(
-        (BoundedInt::<u128>::max() - 1_u128).wrapping_mul(2_u128) == BoundedInt::<u128>::max()
-            - 3_u128,
-        'invalid result'
+    assert_eq!(BoundedInt::<u128>::max().wrapping_add(1_u128), 0_u128);
+    assert_eq!(1_u128.wrapping_add(BoundedInt::<u128>::max()), 0_u128);
+    assert_eq!(BoundedInt::<u128>::max().wrapping_add(2_u128), 1_u128);
+    assert_eq!(2_u128.wrapping_add(BoundedInt::<u128>::max()), 1_u128);
+    assert_eq!(
+        BoundedInt::<u128>::max().wrapping_add(BoundedInt::<u128>::max()),
+        BoundedInt::<u128>::max() - 1_u128
+    );
+    assert_eq!(BoundedInt::<u128>::min().wrapping_sub(1_u128), BoundedInt::<u128>::max());
+    assert_eq!(BoundedInt::<u128>::min().wrapping_sub(2_u128), BoundedInt::<u128>::max() - 1_u128);
+    assert_eq!(1_u128.wrapping_sub(BoundedInt::<u128>::max()), 2_u128);
+    assert_eq!(0_u128.wrapping_sub(BoundedInt::<u128>::max()), 1_u128);
+    assert_eq!(BoundedInt::<u128>::max().wrapping_mul(BoundedInt::<u128>::max()), 1_u128);
+    assert_eq!(
+        (BoundedInt::<u128>::max() - 1_u128).wrapping_mul(2_u128),
+        BoundedInt::<u128>::max() - 3_u128
     );
 
-    assert(BoundedInt::<u256>::max().wrapping_add(1_u256) == 0_u256, 'invalid result');
-    assert(1_u256.wrapping_add(BoundedInt::<u256>::max()) == 0_u256, 'invalid result');
-    assert(BoundedInt::<u256>::max().wrapping_add(2_u256) == 1_u256, 'invalid result');
-    assert(2_u256.wrapping_add(BoundedInt::<u256>::max()) == 1_u256, 'invalid result');
-    assert(
-        BoundedInt::<u256>::max()
-            .wrapping_add(BoundedInt::<u256>::max()) == BoundedInt::<u256>::max()
-            - 1_u256,
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u256>::min().wrapping_sub(1_u256) == BoundedInt::<u256>::max(),
-        'invalid result'
-    );
-    assert(
-        BoundedInt::<u256>::min().wrapping_sub(2_u256) == BoundedInt::<u256>::max() - 1_u256,
-        'invalid result'
-    );
-    assert(1_u256.wrapping_sub(BoundedInt::<u256>::max()) == 2_u256, 'invalid result');
-    assert(0_u256.wrapping_sub(BoundedInt::<u256>::max()) == 1_u256, 'invalid result');
-    assert(
-        BoundedInt::<u256>::max().wrapping_mul(BoundedInt::<u256>::max()) == 1_u256,
-        'invalid result'
-    );
-    assert(
-        (BoundedInt::<u256>::max() - 1_u256).wrapping_mul(2_u256) == BoundedInt::<u256>::max()
-            - 3_u256,
-        'invalid result'
+    assert_eq!(BoundedInt::<u256>::max().wrapping_add(1_u256), 0_u256);
+    assert_eq!(1_u256.wrapping_add(BoundedInt::<u256>::max()), 0_u256);
+    assert_eq!(BoundedInt::<u256>::max().wrapping_add(2_u256), 1_u256);
+    assert_eq!(2_u256.wrapping_add(BoundedInt::<u256>::max()), 1_u256);
+    assert_eq!(
+        BoundedInt::<u256>::max().wrapping_add(BoundedInt::<u256>::max()),
+        BoundedInt::<u256>::max() - 1_u256
+    );
+    assert_eq!(BoundedInt::<u256>::min().wrapping_sub(1_u256), BoundedInt::<u256>::max());
+    assert_eq!(BoundedInt::<u256>::min().wrapping_sub(2_u256), BoundedInt::<u256>::max() - 1_u256);
+    assert_eq!(1_u256.wrapping_sub(BoundedInt::<u256>::max()), 2_u256);
+    assert_eq!(0_u256.wrapping_sub(BoundedInt::<u256>::max()), 1_u256);
+    assert_eq!(BoundedInt::<u256>::max().wrapping_mul(BoundedInt::<u256>::max()), 1_u256);
+    assert_eq!(
+        (BoundedInt::<u256>::max() - 1_u256).wrapping_mul(2_u256),
+        BoundedInt::<u256>::max() - 3_u256
     );
 }