From 29e9591db16166ba5f99b19c24d7b506ab4b8482 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:16:45 -0300 Subject: [PATCH 01/13] Add tests for i8 --- libs/src/signed_integers/i8.sw | 31 +- tests/src/signed_integers/signed_i8/mod.rs | 1 - .../src/signed_integers/signed_i8/src/main.sw | 670 +++++++++++++++--- .../signed_integers/signed_i8/tests/mod.rs | 21 - .../signed_i8_wrapping_neg/.gitignore | 2 - .../signed_i8_wrapping_neg/Forc.toml | 8 - .../signed_i8_wrapping_neg/mod.rs | 1 - .../signed_i8_wrapping_neg/src/main.sw | 60 -- .../signed_i8_wrapping_neg/tests/mod.rs | 22 - 9 files changed, 609 insertions(+), 207 deletions(-) delete mode 100644 tests/src/signed_integers/signed_i8/mod.rs delete mode 100644 tests/src/signed_integers/signed_i8/tests/mod.rs delete mode 100644 tests/src/signed_integers/signed_i8_wrapping_neg/.gitignore delete mode 100644 tests/src/signed_integers/signed_i8_wrapping_neg/Forc.toml delete mode 100644 tests/src/signed_integers/signed_i8_wrapping_neg/mod.rs delete mode 100644 tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i8_wrapping_neg/tests/mod.rs diff --git a/libs/src/signed_integers/i8.sw b/libs/src/signed_integers/i8.sw index e19a288b..32a29d8b 100644 --- a/libs/src/signed_integers/i8.sw +++ b/libs/src/signed_integers/i8.sw @@ -1,6 +1,6 @@ library; -use std::convert::TryFrom; +use std::{convert::{TryFrom, TryInto}, flags::panic_on_unsafe_math_enabled}; use ::signed_integers::errors::Error; use ::signed_integers::common::WrappingNeg; @@ -288,7 +288,10 @@ impl core::ops::Add for I8 { impl core::ops::Divide for I8 { /// Divide a I8 by a I8. Panics if divisor is zero. fn divide(self, divisor: Self) -> Self { - require(divisor != Self::new(), Error::ZeroDivisor); + if panic_on_unsafe_math_enabled() { + require(divisor != Self::new(), Error::ZeroDivisor); + } + let mut res = Self::new(); if self.underlying >= Self::indent() && divisor.underlying > Self::indent() @@ -393,7 +396,7 @@ impl WrappingNeg for I8 { impl TryFrom for I8 { fn try_from(value: u8) -> Option { // as the minimal value of I8 is -I8::indent() (1 << 7) we should add I8::indent() (1 << 7) - if value < u8::max() - Self::indent() { + if value < Self::indent() { Some(Self { underlying: value + Self::indent(), }) @@ -403,6 +406,16 @@ impl TryFrom for I8 { } } +impl TryInto for I8 { + fn try_into(self) -> Option { + if self.underlying >= Self::indent() { + Some(self.underlying - Self::indent()) + } else { + None + } + } +} + impl TryFrom for u8 { fn try_from(value: I8) -> Option { if value >= I8::zero() { @@ -412,3 +425,15 @@ impl TryFrom for u8 { } } } + +impl TryInto for u8 { + fn try_into(self) -> Option { + if self < I8::indent() { + Some(I8 { + underlying: self + I8::indent(), + }) + } else { + None + } + } +} diff --git a/tests/src/signed_integers/signed_i8/mod.rs b/tests/src/signed_integers/signed_i8/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i8/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i8/src/main.sw b/tests/src/signed_integers/signed_i8/src/main.sw index 08586d44..2f88a934 100644 --- a/tests/src/signed_integers/signed_i8/src/main.sw +++ b/tests/src/signed_integers/signed_i8/src/main.sw @@ -1,29 +1,283 @@ -script; +library; use sway_libs::signed_integers::i8::I8; use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; -fn main() -> bool { - let one = I8::try_from(1u8).unwrap(); - let mut res = one + I8::try_from(1u8).unwrap(); - assert(res == I8::try_from(2u8).unwrap()); +#[test] +fn signed_i8_indent() { + assert(I8::indent() == 128u8); +} + +#[test] +fn signed_i8_eq() { + let i8_1 = I8::zero(); + let i8_2 = I8::zero(); + let i8_3 = I8::try_from(1u8).unwrap(); + let i8_4 = I8::try_from(1u8).unwrap(); + let i8_5 = I8::max(); + let i8_6 = I8::max(); + let i8_7 = I8::min(); + let i8_8 = I8::min(); + let i8_9 = I8::neg_try_from(1u8).unwrap(); + let i8_10 = I8::neg_try_from(1u8).unwrap(); + + assert(i8_1 == i8_2); + assert(i8_3 == i8_4); + assert(i8_5 == i8_6); + assert(i8_7 == i8_8); + assert(i8_9 == i8_10); + + assert(i8_1 != i8_3); + assert(i8_1 != i8_5); + assert(i8_1 != i8_7); + assert(i8_1 != i8_9); + + assert(i8_3 != i8_5); + assert(i8_3 != i8_7); + assert(i8_3 != i8_9); + + assert(i8_5 != i8_7); + assert(i8_5 != i8_9); + + assert(i8_7 != i8_9); +} + +#[test] +fn signed_i8_ord() { + let i8_1 = I8::zero(); + let i8_2 = I8::zero(); + let i8_3 = I8::try_from(1u8).unwrap(); + let i8_4 = I8::try_from(1u8).unwrap(); + let i8_5 = I8::max(); + let i8_6 = I8::max(); + let i8_7 = I8::min(); + let i8_8 = I8::min(); + let i8_9 = I8::neg_try_from(1u8).unwrap(); + let i8_10 = I8::neg_try_from(1u8).unwrap(); + + assert(!(i8_1 > i8_2)); + assert(!(i8_3 > i8_4)); + assert(!(i8_5 > i8_6)); + assert(!(i8_7 > i8_8)); + assert(!(i8_9 > i8_10)); + + assert(i8_1 >= i8_2); + assert(i8_3 >= i8_4); + assert(i8_5 >= i8_6); + assert(i8_7 >= i8_8); + assert(i8_9 >= i8_10); + + assert(!(i8_1 < i8_2)); + assert(!(i8_3 < i8_4)); + assert(!(i8_5 < i8_6)); + assert(!(i8_7 < i8_8)); + assert(!(i8_9 < i8_10)); + + assert(i8_1 <= i8_2); + assert(i8_3 <= i8_4); + assert(i8_5 <= i8_6); + assert(i8_7 <= i8_8); + assert(i8_9 <= i8_10); + + assert(i8_1 < i8_3); + assert(i8_1 < i8_5); + assert(i8_3 < i8_5); + assert(i8_7 < i8_5); + assert(i8_9 < i8_5); + assert(i8_9 < i8_1); + assert(i8_9 < i8_3); + assert(i8_7 < i8_9); + + assert(i8_5 > i8_1); + assert(i8_5 > i8_3); + assert(i8_5 > i8_7); + assert(i8_5 > i8_9); + assert(i8_3 > i8_1); + assert(i8_3 > i8_7); + assert(i8_3 > i8_9); + assert(i8_9 > i8_7); +} + +#[test] +fn signed_i8_bits() { + assert(I8::bits() == 8); +} + +#[test] +fn signed_i8_from_uint() { + let zero = I8::from_uint(0u8); + let one = I8::from_uint(1u8); + let max = I8::from_uint(u8::max()); + + assert(zero.underlying() == 0u8); + assert(one.underlying() == 1u8); + assert(max.underlying() == u8::max()); +} + +#[test] +fn signed_i8_max() { + let max = I8::max(); + assert(max.underlying() == u8::max()); +} + +#[test] +fn signed_i8_min() { + let max = I8::min(); + assert(max.underlying() == u8::min()); +} + +#[test] +fn signed_i8_neg_try_from() { + let indent = I8::indent(); + + let neg_try_from_zero = I8::neg_try_from(u8::min()); + assert(neg_try_from_zero.is_some()); + assert(neg_try_from_zero.unwrap() == I8::zero()); + + let neg_try_from_one = I8::neg_try_from(1u8); + assert(neg_try_from_one.is_some()); + assert(neg_try_from_one.unwrap().underlying() == I8::indent() - 1u8); + + let neg_try_from_max = I8::neg_try_from(indent); + assert(neg_try_from_max.is_some()); + assert(neg_try_from_max.unwrap().underlying() == u8::min()); + + let neg_try_from_overflow = I8::neg_try_from(indent + 1u8); + assert(neg_try_from_overflow.is_none()); +} + +#[test] +fn signed_i8_new() { + let new = I8::new(); + + assert(new.underlying() == 128u8); +} + +#[test] +fn signed_i8_zero() { + let zero = I8::zero(); + + assert(zero.underlying() == 128u8); +} + +#[test] +fn signed_i8_is_zero() { + let zero = I8::zero(); + assert(zero.is_zero()); + + let other_1 = I8::from_uint(1); + let other_2 = I8::max(); + assert(!other_1.is_zero()); + assert(!other_2.is_zero()); +} + +#[test] +fn signed_i8_underlying() { + let zero = I8::from_uint(0u8); + let one = I8::from_uint(1u8); + let max = I8::from_uint(u8::max()); + let indent = I8::zero(); + + assert(zero.underlying() == 0u8); + assert(one.underlying() == 1u8); + assert(max.underlying() == u8::max()); + assert(indent.underlying() == 128u8); +} + +#[test] +fn signed_i8_add() { + let pos1 = I8::try_from(1).unwrap(); + let pos2 = I8::try_from(2).unwrap(); + let neg1 = I8::neg_try_from(1).unwrap(); + let neg2 = I8::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 + pos2; + assert(res1 == I8::try_from(3).unwrap()); + + let res2 = pos2 + pos1; + assert(res2 == I8::try_from(3).unwrap()); + + // First positive + let res3 = pos1 + neg1; + assert(res3 == I8::zero()); + + let res4 = pos2 + neg1; + assert(res4 == I8::try_from(1).unwrap()); - res = I8::try_from(10u8).unwrap() - I8::try_from(11u8).unwrap(); - assert(res == I8::try_from(127u8).unwrap()); + let res5 = pos1 + neg2; + assert(res5 == I8::neg_try_from(1).unwrap()); - res = I8::try_from(10u8).unwrap() * I8::try_from(127u8).unwrap(); - assert(res == I8::try_from(118u8).unwrap()); + // Second positive + let res6 = neg1 + pos1; + assert(res6 == I8::zero()); + + let res7 = neg2 + pos1; + assert(res7 == I8::neg_try_from(1).unwrap()); + + let res8 = neg1 + pos2; + assert(res8 == I8::try_from(1).unwrap()); + + // Both negative + let res9 = neg1 + neg2; + assert(res9 == I8::neg_try_from(3).unwrap()); + + let res10 = neg2 + neg1; + assert(res10 == I8::neg_try_from(3).unwrap()); + + // Edge Cases + let res11 = I8::min() + I8::max(); + assert(res11 == I8::neg_try_from(1).unwrap()); + + let res12 = I8::max() + I8::zero(); + assert(res12 == I8::max()); - res = I8::try_from(10u8).unwrap() * I8::try_from(10u8).unwrap(); - assert(res == I8::try_from(100u8).unwrap()); + let res13 = I8::min() + I8::zero(); + assert(res13 == I8::min()); - res = I8::try_from(10u8).unwrap() / I8::try_from(127u8).unwrap(); - assert(res == I8::try_from(118u8).unwrap()); + let res14 = I8::zero() + I8::zero(); + assert(res14 == I8::zero()); +} + +#[test(should_revert)] +fn revert_signed_i8_add() { + let one = I8::try_from(1u8).unwrap(); + let max = I8::max(); + + let _ = max + one; +} + +#[test(should_revert)] +fn revert_signed_i8_add_negative() { + let neg_one = I8::neg_try_from(1u8).unwrap(); + let min = I8::min(); + + let _ = min + neg_one; +} - res = I8::try_from(10u8).unwrap() / I8::try_from(5u8).unwrap(); - assert(res == I8::try_from(2u8).unwrap()); +#[test(should_revert)] +fn revert_signed_i8_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); - // Subtraction Tests + let one = I8::try_from(1u8).unwrap(); + let max = I8::max(); + + let _ = max + one; +} + +#[test] +fn signed_i8_add_overflow() { + let _ = disable_panic_on_overflow(); + + let one = I8::try_from(1u8).unwrap(); + let max = I8::max(); + + assert(max + one == I8::min()); +} + +#[test] +fn signed_i8_subtract() { let pos1 = I8::try_from(1).unwrap(); let pos2 = I8::try_from(2).unwrap(); let neg1 = I8::neg_try_from(1).unwrap(); @@ -40,72 +294,295 @@ fn main() -> bool { let res3 = pos1 - neg1; assert(res3 == I8::try_from(2).unwrap()); + let res4 = pos2 - neg1; + assert(res4 == I8::try_from(3).unwrap()); + // Second positive - let res4 = neg1 - pos1; + let res5 = neg1 - pos1; + assert(res5 == I8::neg_try_from(2).unwrap()); + + let res6 = neg2 - pos1; + assert(res6 == I8::neg_try_from(3).unwrap()); + + // Both negative + let res7 = neg1 - neg2; + assert(res7 == I8::try_from(1).unwrap()); + + let res8 = neg2 - neg1; + assert(res8 == I8::neg_try_from(1).unwrap()); + + // Edge Cases + let res11 = I8::zero() - (I8::min() + I8::try_from(1).unwrap()); + assert(res11 == I8::max()); + + let res12 = I8::max() - I8::zero(); + assert(res12 == I8::max()); + + let res13 = I8::min() - I8::zero(); + assert(res13 == I8::min()); + + let res14 = I8::zero() - I8::zero(); + assert(res14 == I8::zero()); +} + +#[test(should_revert)] +fn revert_signed_i8_sub() { + let min = I8::min(); + let one = I8::try_from(1u8).unwrap(); + + let _ = min - one; +} + +#[test(should_revert)] +fn revert_signed_i8_sub_negative() { + let max = I8::max(); + let neg_one = I8::neg_try_from(1u8).unwrap(); + + let _ = max - neg_one; +} + +#[test(should_revert)] +fn revert_signed_i8_sub_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let min = I8::min(); + let one = I8::try_from(1u8).unwrap(); + + let _ = min - one; +} + +#[test] +fn signed_i8_sub_underflow() { + let _ = disable_panic_on_overflow(); + + let min = I8::min(); + let one = I8::try_from(1u8).unwrap(); + + let result = min - one; + assert(result == I8::max()); +} + +#[test] +fn signed_i8_multiply() { + let pos1 = I8::try_from(1).unwrap(); + let pos2 = I8::try_from(2).unwrap(); + let neg1 = I8::neg_try_from(1).unwrap(); + let neg2 = I8::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 * pos2; + assert(res1 == I8::try_from(2).unwrap()); + + let res2 = pos2 * pos1; + assert(res2 == I8::try_from(2).unwrap()); + + // First positive + let res3 = pos1 * neg1; + assert(res3 == I8::neg_try_from(1).unwrap()); + + let res4 = pos2 * neg1; assert(res4 == I8::neg_try_from(2).unwrap()); + let res5 = pos1 * neg2; + assert(res5 == I8::neg_try_from(2).unwrap()); + + // Second positive + let res6 = neg1 * pos1; + assert(res6 == I8::neg_try_from(1).unwrap()); + + let res7 = neg2 * pos1; + assert(res7 == I8::neg_try_from(2).unwrap()); + + let res8 = neg1 * pos2; + assert(res8 == I8::neg_try_from(2).unwrap()); + // Both negative - let res5 = neg1 - neg2; - assert(res5 == I8::try_from(1).unwrap()); + let res9 = neg1 * neg2; + assert(res9 == I8::try_from(2).unwrap()); + + let res10 = neg2 * neg1; + assert(res10 == I8::try_from(2).unwrap()); + + // Edge Cases + let res12 = I8::max() * I8::zero(); + assert(res12 == I8::zero()); + + let res13 = I8::min() * I8::zero(); + assert(res13 == I8::zero()); + + let res14 = I8::zero() * I8::zero(); + assert(res14 == I8::zero()); +} + +#[test(should_revert)] +fn revert_signed_i8_mul() { + let max = I8::max(); + let two = I8::try_from(2u8).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i8_mul_negatice() { + let max = I8::max(); + let two = I8::neg_try_from(2u8).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i8_mul_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let max = I8::max(); + let two = I8::try_from(2u8).unwrap(); + + let _ = max * two; +} + +#[test] +fn signed_i8_mul() { + let _ = disable_panic_on_overflow(); - let res6 = neg2 - neg1; + let max = I8::max(); + let two = I8::try_from(2u8).unwrap(); + + let result = max * two; + assert(result == I8::neg_try_from(2).unwrap()); +} + +#[test] +fn signed_i8_divide() { + let pos1 = I8::try_from(1).unwrap(); + let pos2 = I8::try_from(2).unwrap(); + let neg1 = I8::neg_try_from(1).unwrap(); + let neg2 = I8::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 / pos2; + assert(res1 == I8::zero()); + + let res2 = pos2 / pos1; + assert(res2 == I8::try_from(2).unwrap()); + + // First positive + let res3 = pos1 / neg1; + assert(res3 == I8::neg_try_from(1).unwrap()); + + let res4 = pos2 / neg1; + assert(res4 == I8::neg_try_from(2).unwrap()); + + let res5 = pos1 / neg2; + assert(res5 == I8::zero()); + + // Second positive + let res6 = neg1 / pos1; assert(res6 == I8::neg_try_from(1).unwrap()); - // OrqEq Tests - let one_1 = I8::try_from(1u8).unwrap(); - let one_2 = I8::try_from(1u8).unwrap(); - let neg_one_1 = I8::neg_try_from(1u8).unwrap(); - let neg_one_2 = I8::neg_try_from(1u8).unwrap(); - let max_1 = I8::max(); - let max_2 = I8::max(); - let min_1 = I8::min(); - let min_2 = I8::min(); - - assert(one_1 >= one_2); - assert(one_1 <= one_2); - assert(neg_one_1 >= neg_one_2); - assert(neg_one_1 <= neg_one_2); - assert(max_1 >= max_1); - assert(max_1 <= max_1); - assert(min_1 >= min_1); - assert(min_1 <= min_1); - - assert(min_1 <= one_1); - assert(min_1 <= neg_one_1); - assert(min_1 <= max_1); - assert(neg_one_1 <= max_1); - assert(neg_one_1 <= one_1); - assert(one_1 <= max_1); - - assert(max_1 >= one_1); - assert(max_1 >= neg_one_1); - assert(max_1 >= min_1); - assert(one_1 >= neg_one_1); - assert(one_1 >= min_1); - assert(neg_one_1 >= min_1); - - // Test neg try from - let indent = I8::indent(); + let res7 = neg2 / pos1; + assert(res7 == I8::neg_try_from(2).unwrap()); - let neg_try_from_zero = I8::neg_try_from(u8::min()); - assert(neg_try_from_zero.is_some()); - assert(neg_try_from_zero.unwrap() == I8::zero()); + let res8 = neg1 / pos2; + assert(res8 == I8::zero()); - let neg_try_from_one = I8::neg_try_from(1u8); - assert(neg_try_from_one.is_some()); - assert(neg_try_from_one.unwrap().underlying() == I8::indent() - 1u8); + // Both negative + let res9 = neg1 / neg2; + assert(res9 == I8::zero()); - let neg_try_from_max = I8::neg_try_from(indent); - assert(neg_try_from_max.is_some()); - assert(neg_try_from_max.unwrap().underlying() == u8::min()); + let res10 = neg2 / neg1; + assert(res10 == I8::try_from(2).unwrap()); - let neg_try_from_overflow = I8::neg_try_from(indent + 1u8); - assert(neg_try_from_overflow.is_none()); + // Edge Cases + let res12 = I8::zero() / I8::max(); + assert(res12 == I8::zero()); + + let res13 = I8::zero() / I8::min(); + assert(res13 == I8::zero()); +} - // Test into I8 +#[test(should_revert)] +fn revert_signed_i8_divide() { + let zero = I8::zero(); + let one = I8::try_from(1u8).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i8_divide_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + let zero = I8::zero(); + let one = I8::try_from(1u8).unwrap(); + + let res = one / zero; + assert(res == I8::zero()); +} + +#[test(should_revert)] +fn revert_signed_i8_divide_disable_overflow() { + let _ = disable_panic_on_overflow(); + let zero = I8::zero(); + let one = I8::try_from(1u8).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i8_wrapping_neg() { + let one = I8::try_from(1u8).unwrap(); + let neg_one = I8::neg_try_from(1u8).unwrap(); + let two = I8::try_from(2u8).unwrap(); + let neg_two = I8::neg_try_from(2u8).unwrap(); + let ten = I8::try_from(10u8).unwrap(); + let neg_ten = I8::neg_try_from(10u8).unwrap(); + let twenty_seven = I8::try_from(27u8).unwrap(); + let neg_twenty_seven = I8::neg_try_from(27u8).unwrap(); + let ninty_three = I8::try_from(93u8).unwrap(); + let neg_ninty_three = I8::neg_try_from(93u8).unwrap(); + let zero = I8::try_from(0u8).unwrap(); + let max = I8::max(); + let min = I8::min(); + let neg_min_plus_one = I8::min() + I8::try_from(1u8).unwrap(); + + let res1 = one.wrapping_neg(); + let res2 = neg_one.wrapping_neg(); + assert(res1 == neg_one); + assert(res2 == one); + + let res3 = two.wrapping_neg(); + let res4 = neg_two.wrapping_neg(); + assert(res3 == neg_two); + assert(res4 == two); + + let res5 = ten.wrapping_neg(); + let res6 = neg_ten.wrapping_neg(); + assert(res5 == neg_ten); + assert(res6 == ten); + + let res7 = twenty_seven.wrapping_neg(); + let res8 = neg_twenty_seven.wrapping_neg(); + assert(res7 == neg_twenty_seven); + assert(res8 == twenty_seven); + + let res9 = ninty_three.wrapping_neg(); + let res10 = neg_ninty_three.wrapping_neg(); + assert(res9 == neg_ninty_three); + assert(res10 == ninty_three); + + let res11 = zero.wrapping_neg(); + let res12 = max.wrapping_neg(); + let res13 = min.wrapping_neg(); + + assert(res11 == zero); + assert(res12 == neg_min_plus_one); + assert(res13 == min); +} + +#[test] +fn signed_i8_try_from_u8() { let indent: u8 = I8::indent(); - let i8_max_try_from = I8::try_from(indent); + let i8_max_try_from = I8::try_from(indent - 1); assert(i8_max_try_from.is_some()); assert(i8_max_try_from.unwrap() == I8::max()); @@ -113,28 +590,39 @@ fn main() -> bool { assert(i8_min_try_from.is_some()); assert(i8_min_try_from.unwrap() == I8::zero()); - let i8_overflow_try_from = I8::try_from(indent + 1); - assert(i8_overflow_try_from.is_none()); + let i8_overflow_try_from = I8::try_from(indent); + assert(i8_overflow_try_from.is_none()); +} - let i8_max_try_into: Option = indent.try_into(); - assert(i8_max_try_into.is_some()); - assert(i8_max_try_into.unwrap() == I8::max()); +#[test] +fn signed_i8_try_into_u8() { + let zero = I8::zero(); + let negative = I8::neg_try_from(1).unwrap(); + let max = I8::max(); + let indent: u8 = I8::indent(); - let i8_min_try_into: Option = u8::min().try_into(); - assert(i8_min_try_into.is_some()); - assert(i8_min_try_into.unwrap() == I8::zero()); + let u8_max_try_into: Option = max.try_into(); + assert(u8_max_try_into.is_some()); + assert(u8_max_try_into.unwrap() == indent - 1); - let i8_overflow_try_into: Option = (indent + 1).try_into(); - assert(i8_overflow_try_into.is_none()); + let u8_min_try_into: Option = zero.try_into(); + assert(u8_min_try_into.is_some()); + assert(u8_min_try_into.unwrap() == u8::zero()); - // Test into u8 + let u8_overflow_try_into: Option = negative.try_into(); + assert(u8_overflow_try_into.is_none()); +} + +#[test] +fn signed_i8_u8_try_from() { let zero = I8::zero(); let negative = I8::neg_try_from(1).unwrap(); let max = I8::max(); + let indent: u8 = I8::indent(); let u8_max_try_from: Option = u8::try_from(max); assert(u8_max_try_from.is_some()); - assert(u8_max_try_from.unwrap() == indent); + assert(u8_max_try_from.unwrap() == indent - 1); let u8_min_try_from: Option = u8::try_from(zero); assert(u8_min_try_from.is_some()); @@ -142,17 +630,21 @@ fn main() -> bool { let u8_overflow_try_from: Option = u8::try_from(negative); assert(u8_overflow_try_from.is_none()); +} - let u8_max_try_into: Option = zero.try_into(); - assert(u8_max_try_into.is_some()); - assert(u8_max_try_into.unwrap() == indent); +#[test] +fn signed_i8_u8_try_into() { + let indent: u8 = I8::indent(); - let u8_min_try_into: Option = zero.try_into(); - assert(u8_min_try_into.is_some()); - assert(u8_min_try_into.unwrap() == u8::zero()); + let i8_max_try_into: Option = (indent - 1).try_into(); + assert(i8_max_try_into.is_some()); + assert(i8_max_try_into.unwrap() == I8::max()); - let u8_overflow_try_into: Option = negative.try_into(); - assert(u8_overflow_try_into.is_none()); + let i8_min_try_into: Option = u8::min().try_into(); + assert(i8_min_try_into.is_some()); + assert(i8_min_try_into.unwrap() == I8::zero()); + + let i8_overflow_try_into: Option = indent.try_into(); + assert(i8_overflow_try_into.is_none()); - true } diff --git a/tests/src/signed_integers/signed_i8/tests/mod.rs b/tests/src/signed_integers/signed_i8/tests/mod.rs deleted file mode 100644 index 70c46a9e..00000000 --- a/tests/src/signed_integers/signed_i8/tests/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi8", - abi = "src/signed_integers/signed_i8/out/release/i8_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i8_test_script() { - let path_to_bin = "src/signed_integers/signed_i8/out/release/i8_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi8::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} diff --git a/tests/src/signed_integers/signed_i8_wrapping_neg/.gitignore b/tests/src/signed_integers/signed_i8_wrapping_neg/.gitignore deleted file mode 100644 index 77d3844f..00000000 --- a/tests/src/signed_integers/signed_i8_wrapping_neg/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -out -target diff --git a/tests/src/signed_integers/signed_i8_wrapping_neg/Forc.toml b/tests/src/signed_integers/signed_i8_wrapping_neg/Forc.toml deleted file mode 100644 index 1ac93c5d..00000000 --- a/tests/src/signed_integers/signed_i8_wrapping_neg/Forc.toml +++ /dev/null @@ -1,8 +0,0 @@ -[project] -authors = ["Fuel Labs "] -entry = "main.sw" -license = "Apache-2.0" -name = "i8_wrapping_neg_test" - -[dependencies] -sway_libs = { path = "../../../../libs" } diff --git a/tests/src/signed_integers/signed_i8_wrapping_neg/mod.rs b/tests/src/signed_integers/signed_i8_wrapping_neg/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i8_wrapping_neg/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw deleted file mode 100644 index 5282dcd6..00000000 --- a/tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i8::I8; - -fn main() -> bool { - let one = I8::try_from(1u8).unwrap(); - let neg_one = I8::neg_try_from(1u8).unwrap(); - - let two = I8::try_from(2u8).unwrap(); - let neg_two = I8::neg_try_from(2u8).unwrap(); - - let ten = I8::try_from(10u8).unwrap(); - let neg_ten = I8::neg_try_from(10u8).unwrap(); - - let twenty_seven = I8::try_from(27u8).unwrap(); - let neg_twenty_seven = I8::neg_try_from(27u8).unwrap(); - - let ninty_three = I8::try_from(93u8).unwrap(); - let neg_ninty_three = I8::neg_try_from(93u8).unwrap(); - - let zero = I8::try_from(0u8).unwrap(); - let max = I8::max(); - let min = I8::min(); - let neg_min_plus_one = I8::min() + I8::try_from(1u8).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i8_wrapping_neg/tests/mod.rs b/tests/src/signed_integers/signed_i8_wrapping_neg/tests/mod.rs deleted file mode 100644 index 4046bb3a..00000000 --- a/tests/src/signed_integers/signed_i8_wrapping_neg/tests/mod.rs +++ /dev/null @@ -1,22 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi8WrappingNeg", - abi = "src/signed_integers/signed_i8_wrapping_neg/out/release/i8_wrapping_neg_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_signed_i8_wrapping_neg_test_script() { - let path_to_bin = - "src/signed_integers/signed_i8_wrapping_neg/out/release/i8_wrapping_neg_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi8WrappingNeg::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} From 7b9ca9c2f69821ae1b5519c92461786b85d01deb Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:17:24 -0300 Subject: [PATCH 02/13] Add tests for i16 --- libs/src/signed_integers/i16.sw | 31 +- tests/src/signed_integers/signed_i16/mod.rs | 1 - .../signed_integers/signed_i16/src/main.sw | 670 +++++++++++++++--- .../signed_integers/signed_i16/tests/mod.rs | 21 - .../signed_i16_wrapping_neg/.gitignore | 2 - .../signed_i16_wrapping_neg/Forc.toml | 8 - .../signed_i16_wrapping_neg/mod.rs | 1 - .../signed_i16_wrapping_neg/src/main.sw | 60 -- .../signed_i16_wrapping_neg/tests/mod.rs | 22 - 9 files changed, 608 insertions(+), 208 deletions(-) delete mode 100644 tests/src/signed_integers/signed_i16/mod.rs delete mode 100644 tests/src/signed_integers/signed_i16/tests/mod.rs delete mode 100644 tests/src/signed_integers/signed_i16_wrapping_neg/.gitignore delete mode 100644 tests/src/signed_integers/signed_i16_wrapping_neg/Forc.toml delete mode 100644 tests/src/signed_integers/signed_i16_wrapping_neg/mod.rs delete mode 100644 tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i16_wrapping_neg/tests/mod.rs diff --git a/libs/src/signed_integers/i16.sw b/libs/src/signed_integers/i16.sw index 5282fa87..6efe0f04 100644 --- a/libs/src/signed_integers/i16.sw +++ b/libs/src/signed_integers/i16.sw @@ -1,6 +1,6 @@ library; -use std::convert::TryFrom; +use std::{convert::{TryFrom, TryInto}, flags::panic_on_unsafe_math_enabled}; use ::signed_integers::errors::Error; use ::signed_integers::common::WrappingNeg; @@ -288,7 +288,10 @@ impl core::ops::Add for I16 { impl core::ops::Divide for I16 { /// Divide a I16 by a I16. Panics if divisor is zero. fn divide(self, divisor: Self) -> Self { - require(divisor != Self::new(), Error::ZeroDivisor); + if panic_on_unsafe_math_enabled() { + require(divisor != Self::new(), Error::ZeroDivisor); + } + let mut res = Self::new(); if self.underlying >= Self::indent() && divisor.underlying > Self::indent() @@ -393,7 +396,7 @@ impl WrappingNeg for I16 { impl TryFrom for I16 { fn try_from(value: u16) -> Option { // as the minimal value of I16 is -I16::indent() (1 << 15) we should add I16::indent() (1 << 15) - if value < u16::max() - Self::indent() { + if value < Self::indent() { Some(Self { underlying: value + Self::indent(), }) @@ -403,6 +406,16 @@ impl TryFrom for I16 { } } +impl TryInto for I16 { + fn try_into(self) -> Option { + if self.underlying >= Self::indent() { + Some(self.underlying - Self::indent()) + } else { + None + } + } +} + impl TryFrom for u16 { fn try_from(value: I16) -> Option { if value >= I16::zero() { @@ -412,3 +425,15 @@ impl TryFrom for u16 { } } } + +impl TryInto for u16 { + fn try_into(self) -> Option { + if self < I16::indent() { + Some(I16 { + underlying: self + I16::indent(), + }) + } else { + None + } + } +} diff --git a/tests/src/signed_integers/signed_i16/mod.rs b/tests/src/signed_integers/signed_i16/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i16/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i16/src/main.sw b/tests/src/signed_integers/signed_i16/src/main.sw index 1f56176c..38690955 100644 --- a/tests/src/signed_integers/signed_i16/src/main.sw +++ b/tests/src/signed_integers/signed_i16/src/main.sw @@ -1,29 +1,283 @@ -script; +library; use sway_libs::signed_integers::i16::I16; use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; -fn main() -> bool { - let one = I16::try_from(1u16).unwrap(); - let mut res = one + I16::try_from(1u16).unwrap(); - assert(res == I16::try_from(2u16).unwrap()); +#[test] +fn signed_i16_indent() { + assert(I16::indent() == 32768u16); +} + +#[test] +fn signed_i16_eq() { + let i16_1 = I16::zero(); + let i16_2 = I16::zero(); + let i16_3 = I16::try_from(1u16).unwrap(); + let i16_4 = I16::try_from(1u16).unwrap(); + let i16_5 = I16::max(); + let i16_6 = I16::max(); + let i16_7 = I16::min(); + let i16_8 = I16::min(); + let i16_9 = I16::neg_try_from(1u16).unwrap(); + let i16_10 = I16::neg_try_from(1u16).unwrap(); + + assert(i16_1 == i16_2); + assert(i16_3 == i16_4); + assert(i16_5 == i16_6); + assert(i16_7 == i16_8); + assert(i16_9 == i16_10); + + assert(i16_1 != i16_3); + assert(i16_1 != i16_5); + assert(i16_1 != i16_7); + assert(i16_1 != i16_9); + + assert(i16_3 != i16_5); + assert(i16_3 != i16_7); + assert(i16_3 != i16_9); + + assert(i16_5 != i16_7); + assert(i16_5 != i16_9); + + assert(i16_7 != i16_9); +} + +#[test] +fn signed_i16_ord() { + let i16_1 = I16::zero(); + let i16_2 = I16::zero(); + let i16_3 = I16::try_from(1u16).unwrap(); + let i16_4 = I16::try_from(1u16).unwrap(); + let i16_5 = I16::max(); + let i16_6 = I16::max(); + let i16_7 = I16::min(); + let i16_8 = I16::min(); + let i16_9 = I16::neg_try_from(1u16).unwrap(); + let i16_10 = I16::neg_try_from(1u16).unwrap(); + + assert(!(i16_1 > i16_2)); + assert(!(i16_3 > i16_4)); + assert(!(i16_5 > i16_6)); + assert(!(i16_7 > i16_8)); + assert(!(i16_9 > i16_10)); + + assert(i16_1 >= i16_2); + assert(i16_3 >= i16_4); + assert(i16_5 >= i16_6); + assert(i16_7 >= i16_8); + assert(i16_9 >= i16_10); + + assert(!(i16_1 < i16_2)); + assert(!(i16_3 < i16_4)); + assert(!(i16_5 < i16_6)); + assert(!(i16_7 < i16_8)); + assert(!(i16_9 < i16_10)); + + assert(i16_1 <= i16_2); + assert(i16_3 <= i16_4); + assert(i16_5 <= i16_6); + assert(i16_7 <= i16_8); + assert(i16_9 <= i16_10); + + assert(i16_1 < i16_3); + assert(i16_1 < i16_5); + assert(i16_3 < i16_5); + assert(i16_7 < i16_5); + assert(i16_9 < i16_5); + assert(i16_9 < i16_1); + assert(i16_9 < i16_3); + assert(i16_7 < i16_9); + + assert(i16_5 > i16_1); + assert(i16_5 > i16_3); + assert(i16_5 > i16_7); + assert(i16_5 > i16_9); + assert(i16_3 > i16_1); + assert(i16_3 > i16_7); + assert(i16_3 > i16_9); + assert(i16_9 > i16_7); +} + +#[test] +fn signed_i16_bits() { + assert(I16::bits() == 16); +} + +#[test] +fn signed_i16_from_uint() { + let zero = I16::from_uint(0u16); + let one = I16::from_uint(1u16); + let max = I16::from_uint(u16::max()); + + assert(zero.underlying() == 0u16); + assert(one.underlying() == 1u16); + assert(max.underlying() == u16::max()); +} + +#[test] +fn signed_i16_max() { + let max = I16::max(); + assert(max.underlying() == u16::max()); +} + +#[test] +fn signed_i16_min() { + let max = I16::min(); + assert(max.underlying() == u16::min()); +} + +#[test] +fn signed_i16_neg_try_from() { + let indent = I16::indent(); + + let neg_try_from_zero = I16::neg_try_from(u16::min()); + assert(neg_try_from_zero.is_some()); + assert(neg_try_from_zero.unwrap() == I16::zero()); + + let neg_try_from_one = I16::neg_try_from(1u16); + assert(neg_try_from_one.is_some()); + assert(neg_try_from_one.unwrap().underlying() == I16::indent() - 1u16); + + let neg_try_from_max = I16::neg_try_from(indent); + assert(neg_try_from_max.is_some()); + assert(neg_try_from_max.unwrap().underlying() == u16::min()); + + let neg_try_from_overflow = I16::neg_try_from(indent + 1u16); + assert(neg_try_from_overflow.is_none()); +} + +#[test] +fn signed_i16_new() { + let new = I16::new(); + + assert(new.underlying() == 32768u16); +} + +#[test] +fn signed_i16_zero() { + let zero = I16::zero(); + + assert(zero.underlying() == 32768u16); +} + +#[test] +fn signed_i16_is_zero() { + let zero = I16::zero(); + assert(zero.is_zero()); + + let other_1 = I16::from_uint(1); + let other_2 = I16::max(); + assert(!other_1.is_zero()); + assert(!other_2.is_zero()); +} + +#[test] +fn signed_i16_underlying() { + let zero = I16::from_uint(0u16); + let one = I16::from_uint(1u16); + let max = I16::from_uint(u16::max()); + let indent = I16::zero(); + + assert(zero.underlying() == 0u16); + assert(one.underlying() == 1u16); + assert(max.underlying() == u16::max()); + assert(indent.underlying() == 32768u16); +} + +#[test] +fn signed_i16_add() { + let pos1 = I16::try_from(1).unwrap(); + let pos2 = I16::try_from(2).unwrap(); + let neg1 = I16::neg_try_from(1).unwrap(); + let neg2 = I16::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 + pos2; + assert(res1 == I16::try_from(3).unwrap()); + + let res2 = pos2 + pos1; + assert(res2 == I16::try_from(3).unwrap()); + + // First positive + let res3 = pos1 + neg1; + assert(res3 == I16::zero()); + + let res4 = pos2 + neg1; + assert(res4 == I16::try_from(1).unwrap()); - res = I16::try_from(10u16).unwrap() - I16::try_from(11u16).unwrap(); - assert(res == I16::try_from(32767u16).unwrap()); + let res5 = pos1 + neg2; + assert(res5 == I16::neg_try_from(1).unwrap()); - res = I16::try_from(10u16).unwrap() * I16::neg_try_from(1u16).unwrap(); - assert(res == I16::neg_try_from(10u16).unwrap()); + // Second positive + let res6 = neg1 + pos1; + assert(res6 == I16::zero()); + + let res7 = neg2 + pos1; + assert(res7 == I16::neg_try_from(1).unwrap()); + + let res8 = neg1 + pos2; + assert(res8 == I16::try_from(1).unwrap()); + + // Both negative + let res9 = neg1 + neg2; + assert(res9 == I16::neg_try_from(3).unwrap()); + + let res10 = neg2 + neg1; + assert(res10 == I16::neg_try_from(3).unwrap()); + + // Edge Cases + let res11 = I16::min() + I16::max(); + assert(res11 == I16::neg_try_from(1).unwrap()); + + let res12 = I16::max() + I16::zero(); + assert(res12 == I16::max()); - res = I16::try_from(10u16).unwrap() * I16::try_from(10u16).unwrap(); - assert(res == I16::try_from(100u16).unwrap()); + let res13 = I16::min() + I16::zero(); + assert(res13 == I16::min()); - res = I16::try_from(10u16).unwrap() / I16::neg_try_from(1u16).unwrap(); - assert(res == I16::neg_try_from(10u16).unwrap()); + let res14 = I16::zero() + I16::zero(); + assert(res14 == I16::zero()); +} + +#[test(should_revert)] +fn revert_signed_i16_add() { + let one = I16::try_from(1u16).unwrap(); + let max = I16::max(); + + let _ = max + one; +} + +#[test(should_revert)] +fn revert_signed_i16_add_negative() { + let neg_one = I16::neg_try_from(1u16).unwrap(); + let min = I16::min(); + + let _ = min + neg_one; +} - res = I16::try_from(10u16).unwrap() / I16::try_from(5u16).unwrap(); - assert(res == I16::try_from(2u16).unwrap()); +#[test(should_revert)] +fn revert_signed_i16_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); - // Subtraction tests + let one = I16::try_from(1u16).unwrap(); + let max = I16::max(); + + let _ = max + one; +} + +#[test] +fn signed_i16_add_overflow() { + let _ = disable_panic_on_overflow(); + + let one = I16::try_from(1u16).unwrap(); + let max = I16::max(); + + assert(max + one == I16::min()); +} + +#[test] +fn signed_i16_subtract() { let pos1 = I16::try_from(1).unwrap(); let pos2 = I16::try_from(2).unwrap(); let neg1 = I16::neg_try_from(1).unwrap(); @@ -31,7 +285,6 @@ fn main() -> bool { // Both positive: let res1 = pos1 - pos2; - let res1_2 = pos2 - pos1; assert(res1 == I16::neg_try_from(1).unwrap()); let res2 = pos2 - pos1; @@ -41,72 +294,295 @@ fn main() -> bool { let res3 = pos1 - neg1; assert(res3 == I16::try_from(2).unwrap()); + let res4 = pos2 - neg1; + assert(res4 == I16::try_from(3).unwrap()); + // Second positive - let res4 = neg1 - pos1; + let res5 = neg1 - pos1; + assert(res5 == I16::neg_try_from(2).unwrap()); + + let res6 = neg2 - pos1; + assert(res6 == I16::neg_try_from(3).unwrap()); + + // Both negative + let res7 = neg1 - neg2; + assert(res7 == I16::try_from(1).unwrap()); + + let res8 = neg2 - neg1; + assert(res8 == I16::neg_try_from(1).unwrap()); + + // Edge Cases + let res11 = I16::zero() - (I16::min() + I16::try_from(1).unwrap()); + assert(res11 == I16::max()); + + let res12 = I16::max() - I16::zero(); + assert(res12 == I16::max()); + + let res13 = I16::min() - I16::zero(); + assert(res13 == I16::min()); + + let res14 = I16::zero() - I16::zero(); + assert(res14 == I16::zero()); +} + +#[test(should_revert)] +fn revert_signed_i16_sub() { + let min = I16::min(); + let one = I16::try_from(1u16).unwrap(); + + let _ = min - one; +} + +#[test(should_revert)] +fn revert_signed_i16_sub_negative() { + let max = I16::max(); + let neg_one = I16::neg_try_from(1u16).unwrap(); + + let _ = max - neg_one; +} + +#[test(should_revert)] +fn revert_signed_i16_sub_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let min = I16::min(); + let one = I16::try_from(1u16).unwrap(); + + let _ = min - one; +} + +#[test] +fn signed_i16_sub_underflow() { + let _ = disable_panic_on_overflow(); + + let min = I16::min(); + let one = I16::try_from(1u16).unwrap(); + + let result = min - one; + assert(result == I16::max()); +} + +#[test] +fn signed_i16_multiply() { + let pos1 = I16::try_from(1).unwrap(); + let pos2 = I16::try_from(2).unwrap(); + let neg1 = I16::neg_try_from(1).unwrap(); + let neg2 = I16::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 * pos2; + assert(res1 == I16::try_from(2).unwrap()); + + let res2 = pos2 * pos1; + assert(res2 == I16::try_from(2).unwrap()); + + // First positive + let res3 = pos1 * neg1; + assert(res3 == I16::neg_try_from(1).unwrap()); + + let res4 = pos2 * neg1; assert(res4 == I16::neg_try_from(2).unwrap()); + let res5 = pos1 * neg2; + assert(res5 == I16::neg_try_from(2).unwrap()); + + // Second positive + let res6 = neg1 * pos1; + assert(res6 == I16::neg_try_from(1).unwrap()); + + let res7 = neg2 * pos1; + assert(res7 == I16::neg_try_from(2).unwrap()); + + let res8 = neg1 * pos2; + assert(res8 == I16::neg_try_from(2).unwrap()); + // Both negative - let res5 = neg1 - neg2; - assert(res5 == I16::try_from(1).unwrap()); + let res9 = neg1 * neg2; + assert(res9 == I16::try_from(2).unwrap()); + + let res10 = neg2 * neg1; + assert(res10 == I16::try_from(2).unwrap()); + + // Edge Cases + let res12 = I16::max() * I16::zero(); + assert(res12 == I16::zero()); + + let res13 = I16::min() * I16::zero(); + assert(res13 == I16::zero()); + + let res14 = I16::zero() * I16::zero(); + assert(res14 == I16::zero()); +} + +#[test(should_revert)] +fn revert_signed_i16_mul() { + let max = I16::max(); + let two = I16::try_from(2u16).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i16_mul_negatice() { + let max = I16::max(); + let two = I16::neg_try_from(2u16).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i16_mul_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let max = I16::max(); + let two = I16::try_from(2u16).unwrap(); + + let _ = max * two; +} + +#[test] +fn signed_i16_mul() { + let _ = disable_panic_on_overflow(); - let res6 = neg2 - neg1; + let max = I16::max(); + let two = I16::try_from(2u16).unwrap(); + + let result = max * two; + assert(result == I16::neg_try_from(2).unwrap()); +} + +#[test] +fn signed_i16_divide() { + let pos1 = I16::try_from(1).unwrap(); + let pos2 = I16::try_from(2).unwrap(); + let neg1 = I16::neg_try_from(1).unwrap(); + let neg2 = I16::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 / pos2; + assert(res1 == I16::zero()); + + let res2 = pos2 / pos1; + assert(res2 == I16::try_from(2).unwrap()); + + // First positive + let res3 = pos1 / neg1; + assert(res3 == I16::neg_try_from(1).unwrap()); + + let res4 = pos2 / neg1; + assert(res4 == I16::neg_try_from(2).unwrap()); + + let res5 = pos1 / neg2; + assert(res5 == I16::zero()); + + // Second positive + let res6 = neg1 / pos1; assert(res6 == I16::neg_try_from(1).unwrap()); - // OrqEq Tests - let one_1 = I16::try_from(1u16).unwrap(); - let one_2 = I16::try_from(1u16).unwrap(); - let neg_one_1 = I16::neg_try_from(1u16).unwrap(); - let neg_one_2 = I16::neg_try_from(1u16).unwrap(); - let max_1 = I16::max(); - let max_2 = I16::max(); - let min_1 = I16::min(); - let min_2 = I16::min(); - - assert(one_1 >= one_2); - assert(one_1 <= one_2); - assert(neg_one_1 >= neg_one_2); - assert(neg_one_1 <= neg_one_2); - assert(max_1 >= max_1); - assert(max_1 <= max_1); - assert(min_1 >= min_1); - assert(min_1 <= min_1); - - assert(min_1 <= one_1); - assert(min_1 <= neg_one_1); - assert(min_1 <= max_1); - assert(neg_one_1 <= max_1); - assert(neg_one_1 <= one_1); - assert(one_1 <= max_1); - - assert(max_1 >= one_1); - assert(max_1 >= neg_one_1); - assert(max_1 >= min_1); - assert(one_1 >= neg_one_1); - assert(one_1 >= min_1); - assert(neg_one_1 >= min_1); - - // Test neg try from - let indent = I16::indent(); + let res7 = neg2 / pos1; + assert(res7 == I16::neg_try_from(2).unwrap()); - let neg_try_from_zero = I16::neg_try_from(u16::min()); - assert(neg_try_from_zero.is_some()); - assert(neg_try_from_zero.unwrap() == I16::zero()); + let res8 = neg1 / pos2; + assert(res8 == I16::zero()); - let neg_try_from_one = I16::neg_try_from(1u16); - assert(neg_try_from_one.is_some()); - assert(neg_try_from_one.unwrap().underlying() == I16::indent() - 1u16); + // Both negative + let res9 = neg1 / neg2; + assert(res9 == I16::zero()); - let neg_try_from_max = I16::neg_try_from(indent); - assert(neg_try_from_max.is_some()); - assert(neg_try_from_max.unwrap().underlying() == u16::min()); + let res10 = neg2 / neg1; + assert(res10 == I16::try_from(2).unwrap()); - let neg_try_from_overflow = I16::neg_try_from(indent + 1u16); - assert(neg_try_from_overflow.is_none()); + // Edge Cases + let res12 = I16::zero() / I16::max(); + assert(res12 == I16::zero()); + + let res13 = I16::zero() / I16::min(); + assert(res13 == I16::zero()); +} - // Test into I16 +#[test(should_revert)] +fn revert_signed_i16_divide() { + let zero = I16::zero(); + let one = I16::try_from(1u16).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i16_divide_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + let zero = I16::zero(); + let one = I16::try_from(1u16).unwrap(); + + let res = one / zero; + assert(res == I16::zero()); +} + +#[test(should_revert)] +fn revert_signed_i16_divide_disable_overflow() { + let _ = disable_panic_on_overflow(); + let zero = I16::zero(); + let one = I16::try_from(1u16).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i16_wrapping_neg() { + let one = I16::try_from(1u16).unwrap(); + let neg_one = I16::neg_try_from(1u16).unwrap(); + let two = I16::try_from(2u16).unwrap(); + let neg_two = I16::neg_try_from(2u16).unwrap(); + let ten = I16::try_from(10u16).unwrap(); + let neg_ten = I16::neg_try_from(10u16).unwrap(); + let twenty_seven = I16::try_from(27u16).unwrap(); + let neg_twenty_seven = I16::neg_try_from(27u16).unwrap(); + let ninty_three = I16::try_from(93u16).unwrap(); + let neg_ninty_three = I16::neg_try_from(93u16).unwrap(); + let zero = I16::try_from(0u16).unwrap(); + let max = I16::max(); + let min = I16::min(); + let neg_min_plus_one = I16::min() + I16::try_from(1u16).unwrap(); + + let res1 = one.wrapping_neg(); + let res2 = neg_one.wrapping_neg(); + assert(res1 == neg_one); + assert(res2 == one); + + let res3 = two.wrapping_neg(); + let res4 = neg_two.wrapping_neg(); + assert(res3 == neg_two); + assert(res4 == two); + + let res5 = ten.wrapping_neg(); + let res6 = neg_ten.wrapping_neg(); + assert(res5 == neg_ten); + assert(res6 == ten); + + let res7 = twenty_seven.wrapping_neg(); + let res8 = neg_twenty_seven.wrapping_neg(); + assert(res7 == neg_twenty_seven); + assert(res8 == twenty_seven); + + let res9 = ninty_three.wrapping_neg(); + let res10 = neg_ninty_three.wrapping_neg(); + assert(res9 == neg_ninty_three); + assert(res10 == ninty_three); + + let res11 = zero.wrapping_neg(); + let res12 = max.wrapping_neg(); + let res13 = min.wrapping_neg(); + + assert(res11 == zero); + assert(res12 == neg_min_plus_one); + assert(res13 == min); +} + +#[test] +fn signed_i16_try_from_u16() { let indent: u16 = I16::indent(); - let i16_max_try_from = I16::try_from(indent); + let i16_max_try_from = I16::try_from(indent - 1); assert(i16_max_try_from.is_some()); assert(i16_max_try_from.unwrap() == I16::max()); @@ -114,28 +590,39 @@ fn main() -> bool { assert(i16_min_try_from.is_some()); assert(i16_min_try_from.unwrap() == I16::zero()); - let i16_overflow_try_from = I16::try_from(indent + 1); - assert(i16_overflow_try_from.is_none()); + let i16_overflow_try_from = I16::try_from(indent); + assert(i16_overflow_try_from.is_none()); +} - let i16_max_try_into: Option = indent.try_into(); - assert(i16_max_try_into.is_some()); - assert(i16_max_try_into.unwrap() == I16::max()); +#[test] +fn signed_i16_try_into_u16() { + let zero = I16::zero(); + let negative = I16::neg_try_from(1).unwrap(); + let max = I16::max(); + let indent: u16 = I16::indent(); - let i16_min_try_into: Option = u16::min().try_into(); - assert(i16_min_try_into.is_some()); - assert(i16_min_try_into.unwrap() == I16::zero()); + let u16_max_try_into: Option = max.try_into(); + assert(u16_max_try_into.is_some()); + assert(u16_max_try_into.unwrap() == indent - 1); - let i16_overflow_try_into: Option = (indent + 1).try_into(); - assert(i16_overflow_try_into.is_none()); + let u16_min_try_into: Option = zero.try_into(); + assert(u16_min_try_into.is_some()); + assert(u16_min_try_into.unwrap() == u16::zero()); - // Test into u16 + let u16_overflow_try_into: Option = negative.try_into(); + assert(u16_overflow_try_into.is_none()); +} + +#[test] +fn signed_i16_u16_try_from() { let zero = I16::zero(); let negative = I16::neg_try_from(1).unwrap(); let max = I16::max(); + let indent: u16 = I16::indent(); let u16_max_try_from: Option = u16::try_from(max); assert(u16_max_try_from.is_some()); - assert(u16_max_try_from.unwrap() == indent); + assert(u16_max_try_from.unwrap() == indent - 1); let u16_min_try_from: Option = u16::try_from(zero); assert(u16_min_try_from.is_some()); @@ -143,17 +630,20 @@ fn main() -> bool { let u16_overflow_try_from: Option = u16::try_from(negative); assert(u16_overflow_try_from.is_none()); +} - let u16_max_try_into: Option = zero.try_into(); - assert(u16_max_try_into.is_some()); - assert(u16_max_try_into.unwrap() == indent); +#[test] +fn signed_i16_u16_try_into() { + let indent: u16 = I16::indent(); - let u16_min_try_into: Option = zero.try_into(); - assert(u16_min_try_into.is_some()); - assert(u16_min_try_into.unwrap() == u16::zero()); + let i16_max_try_into: Option = (indent - 1).try_into(); + assert(i16_max_try_into.is_some()); + assert(i16_max_try_into.unwrap() == I16::max()); - let u16_overflow_try_into: Option = negative.try_into(); - assert(u16_overflow_try_into.is_none()); + let i16_min_try_into: Option = u16::min().try_into(); + assert(i16_min_try_into.is_some()); + assert(i16_min_try_into.unwrap() == I16::zero()); - true + let i16_overflow_try_into: Option = indent.try_into(); + assert(i16_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i16/tests/mod.rs b/tests/src/signed_integers/signed_i16/tests/mod.rs deleted file mode 100644 index 378bd01c..00000000 --- a/tests/src/signed_integers/signed_i16/tests/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi16", - abi = "src/signed_integers/signed_i16/out/release/i16_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i16_test_script() { - let path_to_bin = "src/signed_integers/signed_i16/out/release/i16_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi16::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} diff --git a/tests/src/signed_integers/signed_i16_wrapping_neg/.gitignore b/tests/src/signed_integers/signed_i16_wrapping_neg/.gitignore deleted file mode 100644 index 77d3844f..00000000 --- a/tests/src/signed_integers/signed_i16_wrapping_neg/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -out -target diff --git a/tests/src/signed_integers/signed_i16_wrapping_neg/Forc.toml b/tests/src/signed_integers/signed_i16_wrapping_neg/Forc.toml deleted file mode 100644 index b06e023a..00000000 --- a/tests/src/signed_integers/signed_i16_wrapping_neg/Forc.toml +++ /dev/null @@ -1,8 +0,0 @@ -[project] -authors = ["Fuel Labs "] -entry = "main.sw" -license = "Apache-2.0" -name = "i16_wrapping_neg_test" - -[dependencies] -sway_libs = { path = "../../../../libs" } diff --git a/tests/src/signed_integers/signed_i16_wrapping_neg/mod.rs b/tests/src/signed_integers/signed_i16_wrapping_neg/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i16_wrapping_neg/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw deleted file mode 100644 index 50366666..00000000 --- a/tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i16::I16; - -fn main() -> bool { - let one = I16::try_from(1u16).unwrap(); - let neg_one = I16::neg_try_from(1u16).unwrap(); - - let two = I16::try_from(2u16).unwrap(); - let neg_two = I16::neg_try_from(2u16).unwrap(); - - let ten = I16::try_from(10u16).unwrap(); - let neg_ten = I16::neg_try_from(10u16).unwrap(); - - let twenty_seven = I16::try_from(27u16).unwrap(); - let neg_twenty_seven = I16::neg_try_from(27u16).unwrap(); - - let ninty_three = I16::try_from(93u16).unwrap(); - let neg_ninty_three = I16::neg_try_from(93u16).unwrap(); - - let zero = I16::try_from(0u16).unwrap(); - let max = I16::max(); - let min = I16::min(); - let neg_min_plus_one = I16::min() + I16::try_from(1u16).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i16_wrapping_neg/tests/mod.rs b/tests/src/signed_integers/signed_i16_wrapping_neg/tests/mod.rs deleted file mode 100644 index 9a00a624..00000000 --- a/tests/src/signed_integers/signed_i16_wrapping_neg/tests/mod.rs +++ /dev/null @@ -1,22 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi16WrappingNeg", - abi = "src/signed_integers/signed_i16_wrapping_neg/out/release/i16_wrapping_neg_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_signed_i16_wrapping_neg_test_script() { - let path_to_bin = - "src/signed_integers/signed_i16_wrapping_neg/out/release/i16_wrapping_neg_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi16WrappingNeg::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} From bf3f916e856a5c2c63ddb6d1457228ee3afa472e Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:18:00 -0300 Subject: [PATCH 03/13] Add tests for i32 --- libs/src/signed_integers/i32.sw | 31 +- tests/src/signed_integers/signed_i32/mod.rs | 1 - .../signed_integers/signed_i32/src/main.sw | 671 +++++++++++++++--- .../signed_integers/signed_i32/tests/mod.rs | 21 - .../signed_i32_wrapping_neg/.gitignore | 2 - .../signed_i32_wrapping_neg/Forc.toml | 8 - .../signed_i32_wrapping_neg/mod.rs | 1 - .../signed_i32_wrapping_neg/src/main.sw | 60 -- .../signed_i32_wrapping_neg/tests/mod.rs | 22 - 9 files changed, 609 insertions(+), 208 deletions(-) delete mode 100644 tests/src/signed_integers/signed_i32/mod.rs delete mode 100644 tests/src/signed_integers/signed_i32/tests/mod.rs delete mode 100644 tests/src/signed_integers/signed_i32_wrapping_neg/.gitignore delete mode 100644 tests/src/signed_integers/signed_i32_wrapping_neg/Forc.toml delete mode 100644 tests/src/signed_integers/signed_i32_wrapping_neg/mod.rs delete mode 100644 tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i32_wrapping_neg/tests/mod.rs diff --git a/libs/src/signed_integers/i32.sw b/libs/src/signed_integers/i32.sw index 8ce3da8f..fff6a91a 100644 --- a/libs/src/signed_integers/i32.sw +++ b/libs/src/signed_integers/i32.sw @@ -1,6 +1,6 @@ library; -use std::convert::TryFrom; +use std::{convert::{TryFrom, TryInto}, flags::panic_on_unsafe_math_enabled}; use ::signed_integers::common::WrappingNeg; use ::signed_integers::errors::Error; @@ -346,7 +346,10 @@ impl core::ops::Multiply for I32 { impl core::ops::Divide for I32 { /// Divide a I32 by a I32. Panics if divisor is zero. fn divide(self, divisor: Self) -> Self { - require(divisor != Self::new(), Error::ZeroDivisor); + if panic_on_unsafe_math_enabled() { + require(divisor != Self::new(), Error::ZeroDivisor); + } + let mut res = Self::new(); if self.underlying >= Self::indent() && divisor.underlying > Self::indent() @@ -393,7 +396,7 @@ impl WrappingNeg for I32 { impl TryFrom for I32 { fn try_from(value: u32) -> Option { // as the minimal value of I32 is 2147483648 (1 << 31) we should add I32::indent() (1 << 31) - if value < u32::max() - Self::indent() { + if value < Self::indent() { Some(Self { underlying: value + Self::indent(), }) @@ -403,6 +406,16 @@ impl TryFrom for I32 { } } +impl TryInto for I32 { + fn try_into(self) -> Option { + if self.underlying >= Self::indent() { + Some(self.underlying - Self::indent()) + } else { + None + } + } +} + impl TryFrom for u32 { fn try_from(value: I32) -> Option { if value >= I32::zero() { @@ -412,3 +425,15 @@ impl TryFrom for u32 { } } } + +impl TryInto for u32 { + fn try_into(self) -> Option { + if self < I32::indent() { + Some(I32 { + underlying: self + I32::indent(), + }) + } else { + None + } + } +} diff --git a/tests/src/signed_integers/signed_i32/mod.rs b/tests/src/signed_integers/signed_i32/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i32/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i32/src/main.sw b/tests/src/signed_integers/signed_i32/src/main.sw index ead519ba..5a9f3a29 100644 --- a/tests/src/signed_integers/signed_i32/src/main.sw +++ b/tests/src/signed_integers/signed_i32/src/main.sw @@ -1,29 +1,283 @@ -script; +library; use sway_libs::signed_integers::i32::I32; use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; -fn main() -> bool { - let one = I32::try_from(1u32).unwrap(); - let mut res = one + I32::try_from(1u32).unwrap(); - assert(res == I32::try_from(2u32).unwrap()); +#[test] +fn signed_i32_indent() { + assert(I32::indent() == 2147483648u32); +} + +#[test] +fn signed_i32_eq() { + let i32_1 = I32::zero(); + let i32_2 = I32::zero(); + let i32_3 = I32::try_from(1u32).unwrap(); + let i32_4 = I32::try_from(1u32).unwrap(); + let i32_5 = I32::max(); + let i32_6 = I32::max(); + let i32_7 = I32::min(); + let i32_8 = I32::min(); + let i32_9 = I32::neg_try_from(1u32).unwrap(); + let i32_10 = I32::neg_try_from(1u32).unwrap(); + + assert(i32_1 == i32_2); + assert(i32_3 == i32_4); + assert(i32_5 == i32_6); + assert(i32_7 == i32_8); + assert(i32_9 == i32_10); + + assert(i32_1 != i32_3); + assert(i32_1 != i32_5); + assert(i32_1 != i32_7); + assert(i32_1 != i32_9); + + assert(i32_3 != i32_5); + assert(i32_3 != i32_7); + assert(i32_3 != i32_9); + + assert(i32_5 != i32_7); + assert(i32_5 != i32_9); + + assert(i32_7 != i32_9); +} + +#[test] +fn signed_i32_ord() { + let i32_1 = I32::zero(); + let i32_2 = I32::zero(); + let i32_3 = I32::try_from(1u32).unwrap(); + let i32_4 = I32::try_from(1u32).unwrap(); + let i32_5 = I32::max(); + let i32_6 = I32::max(); + let i32_7 = I32::min(); + let i32_8 = I32::min(); + let i32_9 = I32::neg_try_from(1u32).unwrap(); + let i32_10 = I32::neg_try_from(1u32).unwrap(); + + assert(!(i32_1 > i32_2)); + assert(!(i32_3 > i32_4)); + assert(!(i32_5 > i32_6)); + assert(!(i32_7 > i32_8)); + assert(!(i32_9 > i32_10)); + + assert(i32_1 >= i32_2); + assert(i32_3 >= i32_4); + assert(i32_5 >= i32_6); + assert(i32_7 >= i32_8); + assert(i32_9 >= i32_10); + + assert(!(i32_1 < i32_2)); + assert(!(i32_3 < i32_4)); + assert(!(i32_5 < i32_6)); + assert(!(i32_7 < i32_8)); + assert(!(i32_9 < i32_10)); + + assert(i32_1 <= i32_2); + assert(i32_3 <= i32_4); + assert(i32_5 <= i32_6); + assert(i32_7 <= i32_8); + assert(i32_9 <= i32_10); + + assert(i32_1 < i32_3); + assert(i32_1 < i32_5); + assert(i32_3 < i32_5); + assert(i32_7 < i32_5); + assert(i32_9 < i32_5); + assert(i32_9 < i32_1); + assert(i32_9 < i32_3); + assert(i32_7 < i32_9); + + assert(i32_5 > i32_1); + assert(i32_5 > i32_3); + assert(i32_5 > i32_7); + assert(i32_5 > i32_9); + assert(i32_3 > i32_1); + assert(i32_3 > i32_7); + assert(i32_3 > i32_9); + assert(i32_9 > i32_7); +} + +#[test] +fn signed_i32_bits() { + assert(I32::bits() == 32); +} + +#[test] +fn signed_i32_from_uint() { + let zero = I32::from_uint(0u32); + let one = I32::from_uint(1u32); + let max = I32::from_uint(u32::max()); + + assert(zero.underlying() == 0u32); + assert(one.underlying() == 1u32); + assert(max.underlying() == u32::max()); +} + +#[test] +fn signed_i32_max() { + let max = I32::max(); + assert(max.underlying() == u32::max()); +} + +#[test] +fn signed_i32_min() { + let max = I32::min(); + assert(max.underlying() == u32::min()); +} + +#[test] +fn signed_i32_neg_try_from() { + let indent = I32::indent(); + + let neg_try_from_zero = I32::neg_try_from(u32::min()); + assert(neg_try_from_zero.is_some()); + assert(neg_try_from_zero.unwrap() == I32::zero()); + + let neg_try_from_one = I32::neg_try_from(1u32); + assert(neg_try_from_one.is_some()); + assert(neg_try_from_one.unwrap().underlying() == I32::indent() - 1u32); + + let neg_try_from_max = I32::neg_try_from(indent); + assert(neg_try_from_max.is_some()); + assert(neg_try_from_max.unwrap().underlying() == u32::min()); + + let neg_try_from_overflow = I32::neg_try_from(indent + 1u32); + assert(neg_try_from_overflow.is_none()); +} + +#[test] +fn signed_i32_new() { + let new = I32::new(); + + assert(new.underlying() == 2147483648u32); +} + +#[test] +fn signed_i32_zero() { + let zero = I32::zero(); + + assert(zero.underlying() == 2147483648u32); +} + +#[test] +fn signed_i32_is_zero() { + let zero = I32::zero(); + assert(zero.is_zero()); + + let other_1 = I32::from_uint(1); + let other_2 = I32::max(); + assert(!other_1.is_zero()); + assert(!other_2.is_zero()); +} + +#[test] +fn signed_i32_underlying() { + let zero = I32::from_uint(0u32); + let one = I32::from_uint(1u32); + let max = I32::from_uint(u32::max()); + let indent = I32::zero(); + + assert(zero.underlying() == 0u32); + assert(one.underlying() == 1u32); + assert(max.underlying() == u32::max()); + assert(indent.underlying() == 2147483648u32); +} + +#[test] +fn signed_i32_add() { + let pos1 = I32::try_from(1).unwrap(); + let pos2 = I32::try_from(2).unwrap(); + let neg1 = I32::neg_try_from(1).unwrap(); + let neg2 = I32::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 + pos2; + assert(res1 == I32::try_from(3).unwrap()); + + let res2 = pos2 + pos1; + assert(res2 == I32::try_from(3).unwrap()); + + // First positive + let res3 = pos1 + neg1; + assert(res3 == I32::zero()); + + let res4 = pos2 + neg1; + assert(res4 == I32::try_from(1).unwrap()); - res = I32::try_from(10u32).unwrap() - I32::try_from(11u32).unwrap(); - assert(res == I32::try_from(2147483647u32).unwrap()); + let res5 = pos1 + neg2; + assert(res5 == I32::neg_try_from(1).unwrap()); - res = I32::try_from(10u32).unwrap() * I32::try_from(1u32).unwrap(); - assert(res == I32::neg_try_from(10u32).unwrap()); + // Second positive + let res6 = neg1 + pos1; + assert(res6 == I32::zero()); + + let res7 = neg2 + pos1; + assert(res7 == I32::neg_try_from(1).unwrap()); + + let res8 = neg1 + pos2; + assert(res8 == I32::try_from(1).unwrap()); + + // Both negative + let res9 = neg1 + neg2; + assert(res9 == I32::neg_try_from(3).unwrap()); + + let res10 = neg2 + neg1; + assert(res10 == I32::neg_try_from(3).unwrap()); + + // Edge Cases + let res11 = I32::min() + I32::max(); + assert(res11 == I32::neg_try_from(1).unwrap()); + + let res12 = I32::max() + I32::zero(); + assert(res12 == I32::max()); - res = I32::try_from(10u32).unwrap() * I32::try_from(10u32).unwrap(); - assert(res == I32::try_from(100u32).unwrap()); + let res13 = I32::min() + I32::zero(); + assert(res13 == I32::min()); - res = I32::try_from(10u32).unwrap() / I32::neg_try_from(1u32).unwrap(); - assert(res == I32::neg_try_from(10u32).unwrap()); + let res14 = I32::zero() + I32::zero(); + assert(res14 == I32::zero()); +} + +#[test(should_revert)] +fn revert_signed_i32_add() { + let one = I32::try_from(1u32).unwrap(); + let max = I32::max(); + + let _ = max + one; +} + +#[test(should_revert)] +fn revert_signed_i32_add_negative() { + let neg_one = I32::neg_try_from(1u32).unwrap(); + let min = I32::min(); + + let _ = min + neg_one; +} - res = I32::try_from(10u32).unwrap() / I32::try_from(5u32).unwrap(); - assert(res == I32::try_from(2u32).unwrap()); +#[test(should_revert)] +fn revert_signed_i32_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); - // Subtraction Tests + let one = I32::try_from(1u32).unwrap(); + let max = I32::max(); + + let _ = max + one; +} + +#[test] +fn signed_i32_add_overflow() { + let _ = disable_panic_on_overflow(); + + let one = I32::try_from(1u32).unwrap(); + let max = I32::max(); + + assert(max + one == I32::min()); +} + +#[test] +fn signed_i32_subtract() { let pos1 = I32::try_from(1).unwrap(); let pos2 = I32::try_from(2).unwrap(); let neg1 = I32::neg_try_from(1).unwrap(); @@ -31,7 +285,6 @@ fn main() -> bool { // Both positive: let res1 = pos1 - pos2; - let res1_2 = pos2 - pos1; assert(res1 == I32::neg_try_from(1).unwrap()); let res2 = pos2 - pos1; @@ -41,72 +294,296 @@ fn main() -> bool { let res3 = pos1 - neg1; assert(res3 == I32::try_from(2).unwrap()); + let res4 = pos2 - neg1; + assert(res4 == I32::try_from(3).unwrap()); + // Second positive - let res4 = neg1 - pos1; + let res5 = neg1 - pos1; + assert(res5 == I32::neg_try_from(2).unwrap()); + + let res6 = neg2 - pos1; + assert(res6 == I32::neg_try_from(3).unwrap()); + + // Both negative + let res7 = neg1 - neg2; + assert(res7 == I32::try_from(1).unwrap()); + + let res8 = neg2 - neg1; + assert(res8 == I32::neg_try_from(1).unwrap()); + + // Edge Cases + let res11 = I32::zero() - (I32::min() + I32::try_from(1).unwrap()); + assert(res11 == I32::max()); + + let res12 = I32::max() - I32::zero(); + assert(res12 == I32::max()); + + let res13 = I32::min() - I32::zero(); + assert(res13 == I32::min()); + + let res14 = I32::zero() - I32::zero(); + assert(res14 == I32::zero()); +} + +#[test(should_revert)] +fn revert_signed_i32_sub() { + let min = I32::min(); + let one = I32::try_from(1u32).unwrap(); + + let _ = min - one; +} + +#[test(should_revert)] +fn revert_signed_i32_sub_negative() { + let max = I32::max(); + let neg_one = I32::neg_try_from(1u32).unwrap(); + + let _ = max - neg_one; +} + +#[test(should_revert)] +fn revert_signed_i32_sub_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let min = I32::min(); + let one = I32::try_from(1u32).unwrap(); + + let _ = min - one; +} + +#[test] +fn signed_i32_sub_underflow() { + let _ = disable_panic_on_overflow(); + + let min = I32::min(); + let one = I32::try_from(1u32).unwrap(); + + let result = min - one; + log(result); + assert(result == I32::max()); +} + +#[test] +fn signed_i32_multiply() { + let pos1 = I32::try_from(1).unwrap(); + let pos2 = I32::try_from(2).unwrap(); + let neg1 = I32::neg_try_from(1).unwrap(); + let neg2 = I32::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 * pos2; + assert(res1 == I32::try_from(2).unwrap()); + + let res2 = pos2 * pos1; + assert(res2 == I32::try_from(2).unwrap()); + + // First positive + let res3 = pos1 * neg1; + assert(res3 == I32::neg_try_from(1).unwrap()); + + let res4 = pos2 * neg1; assert(res4 == I32::neg_try_from(2).unwrap()); + let res5 = pos1 * neg2; + assert(res5 == I32::neg_try_from(2).unwrap()); + + // Second positive + let res6 = neg1 * pos1; + assert(res6 == I32::neg_try_from(1).unwrap()); + + let res7 = neg2 * pos1; + assert(res7 == I32::neg_try_from(2).unwrap()); + + let res8 = neg1 * pos2; + assert(res8 == I32::neg_try_from(2).unwrap()); + // Both negative - let res5 = neg1 - neg2; - assert(res5 == I32::try_from(1).unwrap()); + let res9 = neg1 * neg2; + assert(res9 == I32::try_from(2).unwrap()); + + let res10 = neg2 * neg1; + assert(res10 == I32::try_from(2).unwrap()); + + // Edge Cases + let res12 = I32::max() * I32::zero(); + assert(res12 == I32::zero()); + + let res13 = I32::min() * I32::zero(); + assert(res13 == I32::zero()); + + let res14 = I32::zero() * I32::zero(); + assert(res14 == I32::zero()); +} + +#[test(should_revert)] +fn revert_signed_i32_mul() { + let max = I32::max(); + let two = I32::try_from(2u32).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i32_mul_negatice() { + let max = I32::max(); + let two = I32::neg_try_from(2u32).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i32_mul_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let max = I32::max(); + let two = I32::try_from(2u32).unwrap(); + + let _ = max * two; +} + +#[test] +fn signed_i32_mul() { + let _ = disable_panic_on_overflow(); - let res6 = neg2 - neg1; + let max = I32::max(); + let two = I32::try_from(2u32).unwrap(); + + let result = max * two; + assert(result == I32::neg_try_from(2).unwrap()); +} + +#[test] +fn signed_i32_divide() { + let pos1 = I32::try_from(1).unwrap(); + let pos2 = I32::try_from(2).unwrap(); + let neg1 = I32::neg_try_from(1).unwrap(); + let neg2 = I32::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 / pos2; + assert(res1 == I32::zero()); + + let res2 = pos2 / pos1; + assert(res2 == I32::try_from(2).unwrap()); + + // First positive + let res3 = pos1 / neg1; + assert(res3 == I32::neg_try_from(1).unwrap()); + + let res4 = pos2 / neg1; + assert(res4 == I32::neg_try_from(2).unwrap()); + + let res5 = pos1 / neg2; + assert(res5 == I32::zero()); + + // Second positive + let res6 = neg1 / pos1; assert(res6 == I32::neg_try_from(1).unwrap()); - // OrqEq Tests - let one_1 = I32::try_from(1u32).unwrap(); - let one_2 = I32::try_from(1u32).unwrap(); - let neg_one_1 = I32::neg_try_from(1u32).unwrap(); - let neg_one_2 = I32::neg_try_from(1u32).unwrap(); - let max_1 = I32::max(); - let max_2 = I32::max(); - let min_1 = I32::min(); - let min_2 = I32::min(); - - assert(one_1 >= one_2); - assert(one_1 <= one_2); - assert(neg_one_1 >= neg_one_2); - assert(neg_one_1 <= neg_one_2); - assert(max_1 >= max_1); - assert(max_1 <= max_1); - assert(min_1 >= min_1); - assert(min_1 <= min_1); - - assert(min_1 <= one_1); - assert(min_1 <= neg_one_1); - assert(min_1 <= max_1); - assert(neg_one_1 <= max_1); - assert(neg_one_1 <= one_1); - assert(one_1 <= max_1); - - assert(max_1 >= one_1); - assert(max_1 >= neg_one_1); - assert(max_1 >= min_1); - assert(one_1 >= neg_one_1); - assert(one_1 >= min_1); - assert(neg_one_1 >= min_1); - - // Test neg try from - let indent = I32::indent(); + let res7 = neg2 / pos1; + assert(res7 == I32::neg_try_from(2).unwrap()); - let neg_try_from_zero = I32::neg_try_from(u32::min()); - assert(neg_try_from_zero.is_some()); - assert(neg_try_from_zero.unwrap() == I32::zero()); + let res8 = neg1 / pos2; + assert(res8 == I32::zero()); - let neg_try_from_one = I32::neg_try_from(1u32); - assert(neg_try_from_one.is_some()); - assert(neg_try_from_one.unwrap().underlying() == I32::indent() - 1u32); + // Both negative + let res9 = neg1 / neg2; + assert(res9 == I32::zero()); - let neg_try_from_max = I32::neg_try_from(indent); - assert(neg_try_from_max.is_some()); - assert(neg_try_from_max.unwrap().underlying() == u32::min()); + let res10 = neg2 / neg1; + assert(res10 == I32::try_from(2).unwrap()); - let neg_try_from_overflow = I32::neg_try_from(indent + 1u32); - assert(neg_try_from_overflow.is_none()); + // Edge Cases + let res12 = I32::zero() / I32::max(); + assert(res12 == I32::zero()); + + let res13 = I32::zero() / I32::min(); + assert(res13 == I32::zero()); +} - // Test into I32 +#[test(should_revert)] +fn revert_signed_i32_divide() { + let zero = I32::zero(); + let one = I32::try_from(1u32).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i32_divide_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + let zero = I32::zero(); + let one = I32::try_from(1u32).unwrap(); + + let res = one / zero; + assert(res == I32::zero()); +} + +#[test(should_revert)] +fn revert_signed_i32_divide_disable_overflow() { + let _ = disable_panic_on_overflow(); + let zero = I32::zero(); + let one = I32::try_from(1u32).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i32_wrapping_neg() { + let one = I32::try_from(1u32).unwrap(); + let neg_one = I32::neg_try_from(1u32).unwrap(); + let two = I32::try_from(2u32).unwrap(); + let neg_two = I32::neg_try_from(2u32).unwrap(); + let ten = I32::try_from(10u32).unwrap(); + let neg_ten = I32::neg_try_from(10u32).unwrap(); + let twenty_seven = I32::try_from(27u32).unwrap(); + let neg_twenty_seven = I32::neg_try_from(27u32).unwrap(); + let ninty_three = I32::try_from(93u32).unwrap(); + let neg_ninty_three = I32::neg_try_from(93u32).unwrap(); + let zero = I32::try_from(0u32).unwrap(); + let max = I32::max(); + let min = I32::min(); + let neg_min_plus_one = I32::min() + I32::try_from(1u32).unwrap(); + + let res1 = one.wrapping_neg(); + let res2 = neg_one.wrapping_neg(); + assert(res1 == neg_one); + assert(res2 == one); + + let res3 = two.wrapping_neg(); + let res4 = neg_two.wrapping_neg(); + assert(res3 == neg_two); + assert(res4 == two); + + let res5 = ten.wrapping_neg(); + let res6 = neg_ten.wrapping_neg(); + assert(res5 == neg_ten); + assert(res6 == ten); + + let res7 = twenty_seven.wrapping_neg(); + let res8 = neg_twenty_seven.wrapping_neg(); + assert(res7 == neg_twenty_seven); + assert(res8 == twenty_seven); + + let res9 = ninty_three.wrapping_neg(); + let res10 = neg_ninty_three.wrapping_neg(); + assert(res9 == neg_ninty_three); + assert(res10 == ninty_three); + + let res11 = zero.wrapping_neg(); + let res12 = max.wrapping_neg(); + let res13 = min.wrapping_neg(); + + assert(res11 == zero); + assert(res12 == neg_min_plus_one); + assert(res13 == min); +} + +#[test] +fn signed_i32_try_from_u32() { let indent: u32 = I32::indent(); - let i32_max_try_from = I32::try_from(indent); + let i32_max_try_from = I32::try_from(indent - 1); assert(i32_max_try_from.is_some()); assert(i32_max_try_from.unwrap() == I32::max()); @@ -114,28 +591,39 @@ fn main() -> bool { assert(i32_min_try_from.is_some()); assert(i32_min_try_from.unwrap() == I32::zero()); - let i32_overflow_try_from = I32::try_from(indent + 1); - assert(i32_overflow_try_from.is_none()); + let i32_overflow_try_from = I32::try_from(indent); + assert(i32_overflow_try_from.is_none()); +} - let i32_max_try_into: Option = indent.try_into(); - assert(i32_max_try_into.is_some()); - assert(i32_max_try_into.unwrap() == I32::max()); +#[test] +fn signed_i32_try_into_u32() { + let zero = I32::zero(); + let negative = I32::neg_try_from(1).unwrap(); + let max = I32::max(); + let indent: u32 = I32::indent(); - let i32_min_try_into: Option = u32::min().try_into(); - assert(i32_min_try_into.is_some()); - assert(i32_min_try_into.unwrap() == I32::zero()); + let u32_max_try_into: Option = max.try_into(); + assert(u32_max_try_into.is_some()); + assert(u32_max_try_into.unwrap() == indent - 1); - let i32_overflow_try_into: Option = (indent + 1).try_into(); - assert(i32_overflow_try_into.is_none()); + let u32_min_try_into: Option = zero.try_into(); + assert(u32_min_try_into.is_some()); + assert(u32_min_try_into.unwrap() == u32::zero()); - // Test into u32 + let u32_overflow_try_into: Option = negative.try_into(); + assert(u32_overflow_try_into.is_none()); +} + +#[test] +fn signed_i32_u32_try_from() { let zero = I32::zero(); let negative = I32::neg_try_from(1).unwrap(); let max = I32::max(); + let indent: u32 = I32::indent(); let u32_max_try_from: Option = u32::try_from(max); assert(u32_max_try_from.is_some()); - assert(u32_max_try_from.unwrap() == indent); + assert(u32_max_try_from.unwrap() == indent - 1); let u32_min_try_from: Option = u32::try_from(zero); assert(u32_min_try_from.is_some()); @@ -143,17 +631,20 @@ fn main() -> bool { let u32_overflow_try_from: Option = u32::try_from(negative); assert(u32_overflow_try_from.is_none()); +} - let u32_max_try_into: Option = zero.try_into(); - assert(u32_max_try_into.is_some()); - assert(u32_max_try_into.unwrap() == indent); +#[test] +fn signed_i32_u32_try_into() { + let indent: u32 = I32::indent(); - let u32_min_try_into: Option = zero.try_into(); - assert(u32_min_try_into.is_some()); - assert(u32_min_try_into.unwrap() == u32::zero()); + let i32_max_try_into: Option = (indent - 1).try_into(); + assert(i32_max_try_into.is_some()); + assert(i32_max_try_into.unwrap() == I32::max()); - let u32_overflow_try_into: Option = negative.try_into(); - assert(u32_overflow_try_into.is_none()); + let i32_min_try_into: Option = u32::min().try_into(); + assert(i32_min_try_into.is_some()); + assert(i32_min_try_into.unwrap() == I32::zero()); - true + let i32_overflow_try_into: Option = indent.try_into(); + assert(i32_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i32/tests/mod.rs b/tests/src/signed_integers/signed_i32/tests/mod.rs deleted file mode 100644 index acd5be46..00000000 --- a/tests/src/signed_integers/signed_i32/tests/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi32", - abi = "src/signed_integers/signed_i32/out/release/i32_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i32_test_script() { - let path_to_bin = "src/signed_integers/signed_i32/out/release/i32_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi32::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} diff --git a/tests/src/signed_integers/signed_i32_wrapping_neg/.gitignore b/tests/src/signed_integers/signed_i32_wrapping_neg/.gitignore deleted file mode 100644 index 77d3844f..00000000 --- a/tests/src/signed_integers/signed_i32_wrapping_neg/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -out -target diff --git a/tests/src/signed_integers/signed_i32_wrapping_neg/Forc.toml b/tests/src/signed_integers/signed_i32_wrapping_neg/Forc.toml deleted file mode 100644 index 77f6b6fc..00000000 --- a/tests/src/signed_integers/signed_i32_wrapping_neg/Forc.toml +++ /dev/null @@ -1,8 +0,0 @@ -[project] -authors = ["Fuel Labs "] -entry = "main.sw" -license = "Apache-2.0" -name = "i32_wrapping_neg_test" - -[dependencies] -sway_libs = { path = "../../../../libs" } diff --git a/tests/src/signed_integers/signed_i32_wrapping_neg/mod.rs b/tests/src/signed_integers/signed_i32_wrapping_neg/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i32_wrapping_neg/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw deleted file mode 100644 index bdb2c19f..00000000 --- a/tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i32::I32; - -fn main() -> bool { - let one = I32::try_from(1u32).unwrap(); - let neg_one = I32::neg_try_from(1u32).unwrap(); - - let two = I32::try_from(2u32).unwrap(); - let neg_two = I32::neg_try_from(2u32).unwrap(); - - let ten = I32::try_from(10u32).unwrap(); - let neg_ten = I32::neg_try_from(10u32).unwrap(); - - let twenty_seven = I32::try_from(27u32).unwrap(); - let neg_twenty_seven = I32::neg_try_from(27u32).unwrap(); - - let ninty_three = I32::try_from(93u32).unwrap(); - let neg_ninty_three = I32::neg_try_from(93u32).unwrap(); - - let zero = I32::try_from(0u32).unwrap(); - let max = I32::max(); - let min = I32::min(); - let neg_min_plus_one = I32::min() + I32::try_from(1u32).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i32_wrapping_neg/tests/mod.rs b/tests/src/signed_integers/signed_i32_wrapping_neg/tests/mod.rs deleted file mode 100644 index cbf3f824..00000000 --- a/tests/src/signed_integers/signed_i32_wrapping_neg/tests/mod.rs +++ /dev/null @@ -1,22 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi32WrappingNeg", - abi = "src/signed_integers/signed_i32_wrapping_neg/out/release/i32_wrapping_neg_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i32_wrapping_neg_test_script() { - let path_to_bin = - "src/signed_integers/signed_i32_wrapping_neg/out/release/i32_wrapping_neg_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi32WrappingNeg::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} From cdeab5b5e37eccd3c1bc2496bd5c9fb0066199cb Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:18:30 -0300 Subject: [PATCH 04/13] Add tests for i128 --- libs/src/signed_integers/i128.sw | 32 +- tests/src/signed_integers/signed_i128/mod.rs | 1 - .../signed_integers/signed_i128/src/main.sw | 756 +++++++++++++++--- .../signed_integers/signed_i128/tests/mod.rs | 21 - .../signed_i128_wrapping_neg/.gitignore | 2 - .../signed_i128_wrapping_neg/Forc.toml | 8 - .../signed_i128_wrapping_neg/mod.rs | 1 - .../signed_i128_wrapping_neg/src/main.sw | 61 -- .../signed_i128_wrapping_neg/tests/mod.rs | 23 - 9 files changed, 685 insertions(+), 220 deletions(-) delete mode 100644 tests/src/signed_integers/signed_i128/mod.rs delete mode 100644 tests/src/signed_integers/signed_i128/tests/mod.rs delete mode 100644 tests/src/signed_integers/signed_i128_wrapping_neg/.gitignore delete mode 100644 tests/src/signed_integers/signed_i128_wrapping_neg/Forc.toml delete mode 100644 tests/src/signed_integers/signed_i128_wrapping_neg/mod.rs delete mode 100644 tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i128_wrapping_neg/tests/mod.rs diff --git a/libs/src/signed_integers/i128.sw b/libs/src/signed_integers/i128.sw index 6e93c481..68065702 100644 --- a/libs/src/signed_integers/i128.sw +++ b/libs/src/signed_integers/i128.sw @@ -1,6 +1,6 @@ library; -use std::{convert::TryFrom, u128::U128}; +use std::{convert::{TryFrom, TryInto}, flags::panic_on_unsafe_math_enabled, u128::U128}; use ::signed_integers::common::WrappingNeg; use ::signed_integers::errors::Error; @@ -298,8 +298,10 @@ impl core::ops::Add for I128 { impl core::ops::Divide for I128 { /// Divide a I128 by a I128. Panics if divisor is zero. fn divide(self, divisor: Self) -> Self { - require(divisor != Self::new(), Error::ZeroDivisor); - let mut res = Self::new(); + if panic_on_unsafe_math_enabled() { + require(divisor != Self::new(), Error::ZeroDivisor); + } + let mut res = Self::new(); if (self.underlying > Self::indent() || self.underlying == Self::indent()) && divisor.underlying > Self::indent() @@ -405,7 +407,7 @@ impl WrappingNeg for I128 { impl TryFrom for I128 { fn try_from(value: U128) -> Option { // as the minimal value of I128 is -I128::indent() (1 << 63) we should add I128::indent() (1 << 63) - if value < U128::max() - Self::indent() { + if value < Self::indent() { Some(Self { underlying: value + Self::indent(), }) @@ -415,6 +417,16 @@ impl TryFrom for I128 { } } +impl TryInto for I128 { + fn try_into(self) -> Option { + if self.underlying >= Self::indent() { + Some(self.underlying - Self::indent()) + } else { + None + } + } +} + impl TryFrom for U128 { fn try_from(value: I128) -> Option { if value >= I128::zero() { @@ -424,3 +436,15 @@ impl TryFrom for U128 { } } } + +impl TryInto for U128 { + fn try_into(self) -> Option { + if self < I128::indent() { + Some(I128 { + underlying: self + I128::indent(), + }) + } else { + None + } + } +} diff --git a/tests/src/signed_integers/signed_i128/mod.rs b/tests/src/signed_integers/signed_i128/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i128/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i128/src/main.sw b/tests/src/signed_integers/signed_i128/src/main.sw index 681271b0..8bf45ebc 100644 --- a/tests/src/signed_integers/signed_i128/src/main.sw +++ b/tests/src/signed_integers/signed_i128/src/main.sw @@ -1,41 +1,356 @@ -script; +library; use sway_libs::signed_integers::i128::I128; -use std::u128::U128; use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; +use std::u128::U128; + +#[test] +fn signed_i128_indent() { + assert(I128::indent() == U128::from((9223372036854775808, 0))); +} + +#[test] +fn signed_i128_eq() { + let i128_1 = I128::zero(); + let i128_2 = I128::zero(); + let i128_3 = I128::try_from(U128::from((0, 1))).unwrap(); + let i128_4 = I128::try_from(U128::from((0, 1))).unwrap(); + let i128_5 = I128::max(); + let i128_6 = I128::max(); + let i128_7 = I128::min(); + let i128_8 = I128::min(); + let i128_9 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let i128_10 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let i128_11 = I128::try_from(U128::from((1, 0))).unwrap(); + let i128_12 = I128::try_from(U128::from((1, 0))).unwrap(); + let i128_13 = I128::neg_try_from(U128::from((1, 0))).unwrap(); + let i128_14= I128::neg_try_from(U128::from((1, 0))).unwrap(); + + assert(i128_1 == i128_2); + assert(i128_3 == i128_4); + assert(i128_5 == i128_6); + assert(i128_7 == i128_8); + assert(i128_9 == i128_10); + assert(i128_11 == i128_12); + assert(i128_13 == i128_14); + + assert(i128_1 != i128_3); + assert(i128_1 != i128_5); + assert(i128_1 != i128_7); + assert(i128_1 != i128_9); + assert(i128_1 != i128_11); + assert(i128_1 != i128_13); + + assert(i128_3 != i128_5); + assert(i128_3 != i128_7); + assert(i128_3 != i128_9); + assert(i128_3 != i128_11); + assert(i128_3 != i128_13); + + assert(i128_5 != i128_7); + assert(i128_5 != i128_9); + assert(i128_5 != i128_11); + assert(i128_5 != i128_13); + + assert(i128_7 != i128_9); + assert(i128_7 != i128_11); + assert(i128_7 != i128_13); + + assert(i128_9 != i128_11); + assert(i128_9 != i128_13); + + assert(i128_11 != i128_13); +} + +#[test] +fn signed_i128_ord() { + let i128_1 = I128::zero(); + let i128_2 = I128::zero(); + let i128_3 = I128::try_from(U128::from((0, 1))).unwrap(); + let i128_4 = I128::try_from(U128::from((0, 1))).unwrap(); + let i128_5 = I128::max(); + let i128_6 = I128::max(); + let i128_7 = I128::min(); + let i128_8 = I128::min(); + let i128_9 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let i128_10 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let i128_11 = I128::try_from(U128::from((1, 0))).unwrap(); + let i128_12 = I128::try_from(U128::from((1, 0))).unwrap(); + let i128_13 = I128::neg_try_from(U128::from((1, 0))).unwrap(); + let i128_14= I128::neg_try_from(U128::from((1, 0))).unwrap(); + + assert(!(i128_1 > i128_2)); + assert(!(i128_3 > i128_4)); + assert(!(i128_5 > i128_6)); + assert(!(i128_7 > i128_8)); + assert(!(i128_9 > i128_10)); + assert(!(i128_11 > i128_12)); + assert(!(i128_13 > i128_14)); + + assert(i128_1 >= i128_2); + assert(i128_3 >= i128_4); + assert(i128_5 >= i128_6); + assert(i128_7 >= i128_8); + assert(i128_9 >= i128_10); + assert(i128_11 >= i128_12); + assert(i128_13 >= i128_14); + + assert(!(i128_1 < i128_2)); + assert(!(i128_3 < i128_4)); + assert(!(i128_5 < i128_6)); + assert(!(i128_7 < i128_8)); + assert(!(i128_9 < i128_10)); + assert(!(i128_11 < i128_12)); + assert(!(i128_13 < i128_14)); + + assert(i128_1 <= i128_2); + assert(i128_3 <= i128_4); + assert(i128_5 <= i128_6); + assert(i128_7 <= i128_8); + assert(i128_9 <= i128_10); + assert(i128_11 <= i128_12); + assert(i128_13 <= i128_14); + + assert(i128_1 < i128_3); + assert(i128_1 < i128_5); + assert(i128_3 < i128_5); + assert(i128_7 < i128_5); + assert(i128_9 < i128_5); + assert(i128_9 < i128_1); + assert(i128_9 < i128_3); + assert(i128_7 < i128_9); + assert(i128_9 < i128_12); + assert(i128_13 < i128_9); + assert(i128_13 < i128_11); + + assert(i128_5 > i128_1); + assert(i128_5 > i128_3); + assert(i128_5 > i128_7); + assert(i128_5 > i128_9); + assert(i128_3 > i128_1); + assert(i128_3 > i128_7); + assert(i128_3 > i128_9); + assert(i128_9 > i128_7); + assert(i128_11 > i128_9); + assert(i128_9 > i128_13); + assert(i128_11 > i128_13); +} + +#[test] +fn signed_i128_bits() { + assert(I128::bits() == 128); +} + +#[test] +fn signed_i128_from_uint() { + let zero = I128::from_uint(U128::zero()); + let one = I128::from_uint(U128::from((0, 1))); + let upper = I128::from_uint(U128::from((1, 0))); + let max = I128::from_uint(U128::max()); + + assert(zero.underlying() == U128::zero()); + assert(one.underlying() == U128::from((0, 1))); + assert(upper.underlying() == U128::from((1, 0))); + assert(max.underlying() == U128::max()); +} + +#[test] +fn signed_i128_max() { + let max = I128::max(); + assert(max.underlying() == U128::max()); +} + +#[test] +fn signed_i128_min() { + let max = I128::min(); + assert(max.underlying() == U128::min()); +} + +#[test] +fn signed_i128_neg_try_from() { + let indent = I128::indent(); + + let neg_try_from_zero = I128::neg_try_from(U128::min()); + assert(neg_try_from_zero.is_some()); + assert(neg_try_from_zero.unwrap() == I128::zero()); + + let neg_try_from_one = I128::neg_try_from(U128::from((0, 1))); + assert(neg_try_from_one.is_some()); + assert(neg_try_from_one.unwrap().underlying() == I128::indent() - U128::from((0, 1))); + + let neg_try_from_max = I128::neg_try_from(indent); + assert(neg_try_from_max.is_some()); + assert(neg_try_from_max.unwrap().underlying() == U128::min()); + + let neg_try_from_overflow = I128::neg_try_from(indent + U128::from((0, 1))); + assert(neg_try_from_overflow.is_none()); +} + +#[test] +fn signed_i128_new() { + let new = I128::new(); + + assert(new.underlying() == U128::from((9223372036854775808, 0))); +} + +#[test] +fn signed_i128_zero() { + let zero = I128::zero(); + + assert(zero.underlying() == U128::from((9223372036854775808, 0))); +} + +#[test] +fn signed_i128_is_zero() { + let zero = I128::zero(); + assert(zero.is_zero()); + + let other_1 = I128::from_uint(U128::from((0, 1))); + let other_2 = I128::max(); + assert(!other_1.is_zero()); + assert(!other_2.is_zero()); +} + +#[test] +fn signed_i128_underlying() { + let zero = I128::from_uint(U128::zero()); + let one = I128::from_uint(U128::from((0, 1))); + let max = I128::from_uint(U128::max()); + let indent = I128::zero(); + + assert(zero.underlying() == U128::zero()); + assert(one.underlying() == U128::from((0, 1))); + assert(max.underlying() == U128::max()); + assert(indent.underlying() == U128::from((9223372036854775808, 0))); +} + +#[test] +fn signed_i128_add() { + let pos1 = I128::try_from(U128::from((0, 1))).unwrap(); + let pos2 = I128::try_from(U128::from((0, 2))).unwrap(); + let neg1 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let neg2 = I128::neg_try_from(U128::from((0, 2))).unwrap(); + let upper1 = I128::try_from(U128::from((1, 0))).unwrap(); + let upper2 = I128::try_from(U128::from((2, 0))).unwrap(); + let neg_upper1 = I128::neg_try_from(U128::from((1, 0))).unwrap(); + let neg_upper2 = I128::neg_try_from(U128::from((2, 0))).unwrap(); + // Both positive: + let res1 = pos1 + pos2; + assert(res1 == I128::try_from(U128::from((0, 3))).unwrap()); + + let res2 = pos2 + pos1; + assert(res2 == I128::try_from(U128::from((0, 3))).unwrap()); + + let upper_res1 = upper1 + upper2; + assert(upper_res1 == I128::try_from(U128::from((3, 0))).unwrap()); + + let upper_res2 = upper2 + upper1; + assert(upper_res2 == I128::try_from(U128::from((3, 0))).unwrap()); -fn main() -> bool { - let u128_one = U128::from((0, 1)); - let u128_two = U128::from((0, 2)); - let one = I128::try_from(u128_one).unwrap(); - let mut res = one + I128::try_from(u128_one).unwrap(); - assert(res == I128::try_from(u128_two).unwrap()); + // First positive + let res3 = pos1 + neg1; + assert(res3 == I128::zero()); + + let res4 = pos2 + neg1; + assert(res4 == I128::try_from(U128::from((0, 1))).unwrap()); + + let res5 = pos1 + neg2; + assert(res5 == I128::neg_try_from(U128::from((0, 1))).unwrap()); + + let upper_res3 = upper1 + neg_upper1; + assert(upper_res3 == I128::zero()); - let u128_10 = U128::from((0, 10)); - let u128_11 = U128::from((0, 11)); - res = I128::try_from(u128_10).unwrap() - I128::try_from(u128_11).unwrap(); - assert(res.underlying().lower() == u64::max()); + let upper_res4 = upper2 + neg_upper1; + assert(upper_res4 == I128::try_from(U128::from((1, 0))).unwrap()); - res = I128::try_from(u128_10).unwrap() * I128::neg_try_from(u128_one).unwrap(); - assert(res == I128::neg_try_from(u128_10).unwrap()); + let upper_res5 = upper1 + neg_upper2; + assert(upper_res5 == I128::neg_try_from(U128::from((1, 0))).unwrap()); - res = I128::try_from(u128_10).unwrap() * I128::try_from(u128_10).unwrap(); - let u128_100 = U128::from((0, 100)); - assert(res == I128::try_from(u128_100).unwrap()); + // Second positive + let res6 = neg1 + pos1; + assert(res6 == I128::zero()); + + let res7 = neg2 + pos1; + assert(res7 == I128::neg_try_from(U128::from((0, 1))).unwrap()); - let u128_lower_max_u64 = U128::from((0, u64::max())); + let res8 = neg1 + pos2; + assert(res8 == I128::try_from(U128::from((0, 1))).unwrap()); - res = I128::try_from(u128_10).unwrap() / I128::try_from(u128_lower_max_u64).unwrap(); - assert(res == I128::neg_try_from(u128_10).unwrap()); + let upper_res6 = neg_upper1 + upper1; + assert(upper_res6 == I128::zero()); - let u128_5 = U128::from((0, 5)); + let upper_res7 = neg_upper2 + upper1; + assert(upper_res7 == I128::neg_try_from(U128::from((1, 0))).unwrap()); - let u128_2 = U128::from((0, 2)); + let upper_res8 = neg_upper1 + upper2; + assert(upper_res8 == I128::try_from(U128::from((1, 0))).unwrap()); + + // Both negative + let res9 = neg1 + neg2; + assert(res9 == I128::neg_try_from(U128::from((0, 3))).unwrap()); - res = I128::try_from(u128_10).unwrap() / I128::try_from(u128_5).unwrap(); - assert(res == I128::try_from(u128_2).unwrap()); + let res10 = neg2 + neg1; + assert(res10 == I128::neg_try_from(U128::from((0, 3))).unwrap()); + + let upper_res9 = neg_upper1 + neg_upper2; + assert(upper_res9 == I128::neg_try_from(U128::from((3, 0))).unwrap()); + + let upper_res10 = neg_upper2 + neg_upper1; + assert(upper_res10 == I128::neg_try_from(U128::from((3, 0))).unwrap()); + + // Edge Cases + let res11 = I128::min() + I128::max(); + assert(res11 == I128::neg_try_from(U128::from((0, 1))).unwrap()); + + let res12 = I128::max() + I128::zero(); + assert(res12 == I128::max()); + + let res13 = I128::min() + I128::zero(); + assert(res13 == I128::min()); + + let res14 = I128::zero() + I128::zero(); + assert(res14 == I128::zero()); +} - // Subtraction tests +#[test(should_revert)] +fn revert_signed_i128_add() { + let one = I128::try_from(U128::from((0, 1))).unwrap(); + let max = I128::max(); + + let _ = max + one; +} + +#[test(should_revert)] +fn revert_signed_i128_add_negative() { + let neg_one = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let min = I128::min(); + + let _ = min + neg_one; +} + +#[test(should_revert)] +fn revert_signed_i128_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let one = I128::try_from(U128::from((0, 1))).unwrap(); + let max = I128::max(); + + let _ = max + one; +} + +#[test] +fn signed_i128_add_overflow() { + let _ = disable_panic_on_overflow(); + + let one = I128::try_from(U128::from((0, 1))).unwrap(); + let max = I128::max(); + + assert(max + one == I128::min()); +} + +#[test] +fn signed_i128_subtract() { let pos1 = I128::try_from(U128::from((0, 1))).unwrap(); let pos2 = I128::try_from(U128::from((0, 2))).unwrap(); let neg1 = I128::neg_try_from(U128::from((0, 1))).unwrap(); @@ -43,7 +358,6 @@ fn main() -> bool { // Both positive: let res1 = pos1 - pos2; - let res1_2 = pos2 - pos1; assert(res1 == I128::neg_try_from(U128::from((0, 1))).unwrap()); let res2 = pos2 - pos1; @@ -53,72 +367,302 @@ fn main() -> bool { let res3 = pos1 - neg1; assert(res3 == I128::try_from(U128::from((0, 2))).unwrap()); + let res4 = pos2 - neg1; + assert(res4 == I128::try_from(U128::from((0, 3))).unwrap()); + // Second positive - let res4 = neg1 - pos1; + let res5 = neg1 - pos1; + assert(res5 == I128::neg_try_from(U128::from((0, 2))).unwrap()); + + let res6 = neg2 - pos1; + assert(res6 == I128::neg_try_from(U128::from((0, 3))).unwrap()); + + // Both negative + let res7 = neg1 - neg2; + assert(res7 == I128::try_from(U128::from((0, 1))).unwrap()); + + let res8 = neg2 - neg1; + assert(res8 == I128::neg_try_from(U128::from((0, 1))).unwrap()); + + // Edge Cases + let res11 = I128::zero() - (I128::min() + I128::try_from(U128::from((0, 1))).unwrap()); + assert(res11 == I128::max()); + + let res12 = I128::max() - I128::zero(); + assert(res12 == I128::max()); + + let res13 = I128::min() - I128::zero(); + assert(res13 == I128::min()); + + let res14 = I128::zero() - I128::zero(); + assert(res14 == I128::zero()); +} + +#[test(should_revert)] +fn revert_signed_i128_sub() { + let min = I128::min(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); + + let _ = min - one; +} + +#[test(should_revert)] +fn revert_signed_i128_sub_negative() { + let max = I128::max(); + let neg_one = I128::neg_try_from(U128::from((0, 1))).unwrap(); + + let _ = max - neg_one; +} + +#[test(should_revert)] +fn revert_signed_i128_sub_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let min = I128::min(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); + + let _ = min - one; +} + +#[test] +fn signed_i128_sub_underflow() { + let _ = disable_panic_on_overflow(); + + let min = I128::min(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); + + let result = min - one; + assert(result == I128::max()); +} + +#[test] +fn signed_i128_multiply() { + let pos1 = I128::try_from(U128::from((0, 1))).unwrap(); + let pos2 = I128::try_from(U128::from((0, 2))).unwrap(); + let neg1 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let neg2 = I128::neg_try_from(U128::from((0, 2))).unwrap(); + + // Both positive: + let res1 = pos1 * pos2; + assert(res1 == I128::try_from(U128::from((0, 2))).unwrap()); + + let res2 = pos2 * pos1; + assert(res2 == I128::try_from(U128::from((0, 2))).unwrap()); + + // First positive + let res3 = pos1 * neg1; + assert(res3 == I128::neg_try_from(U128::from((0, 1))).unwrap()); + + let res4 = pos2 * neg1; assert(res4 == I128::neg_try_from(U128::from((0, 2))).unwrap()); + let res5 = pos1 * neg2; + assert(res5 == I128::neg_try_from(U128::from((0, 2))).unwrap()); + + // Second positive + let res6 = neg1 * pos1; + assert(res6 == I128::neg_try_from(U128::from((0, 1))).unwrap()); + + let res7 = neg2 * pos1; + assert(res7 == I128::neg_try_from(U128::from((0, 2))).unwrap()); + + let res8 = neg1 * pos2; + assert(res8 == I128::neg_try_from(U128::from((0, 2))).unwrap()); + // Both negative - let res5 = neg1 - neg2; - assert(res5 == I128::try_from(U128::from((0, 1))).unwrap()); + let res9 = neg1 * neg2; + assert(res9 == I128::try_from(U128::from((0, 2))).unwrap()); + + let res10 = neg2 * neg1; + assert(res10 == I128::try_from(U128::from((0, 2))).unwrap()); + + // Edge Cases + let res12 = I128::max() * I128::zero(); + assert(res12 == I128::zero()); + + let res13 = I128::min() * I128::zero(); + assert(res13 == I128::zero()); - let res6 = neg2 - neg1; + let res14 = I128::zero() * I128::zero(); + assert(res14 == I128::zero()); +} + +#[test(should_revert)] +fn revert_signed_i128_mul() { + let max = I128::max(); + let two = I128::try_from(U128::from((0, 2))).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i128_mul_negatice() { + let max = I128::max(); + let two = I128::neg_try_from(U128::from((0, 2))).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i128_mul_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let max = I128::max(); + let two = I128::try_from(U128::from((0, 2))).unwrap(); + + let _ = max * two; +} + +#[test] +fn signed_i128_mul() { + let _ = disable_panic_on_overflow(); + + let max = I128::max(); + let two = I128::try_from(U128::from((0, 2))).unwrap(); + + let result = max * two; + assert(result == I128::neg_try_from(U128::from((0, 2))).unwrap()); +} + +#[test] +fn signed_i128_divide() { + let pos1 = I128::try_from(U128::from((0, 1))).unwrap(); + let pos2 = I128::try_from(U128::from((0, 2))).unwrap(); + let neg1 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let neg2 = I128::neg_try_from(U128::from((0, 2))).unwrap(); + + // Both positive: + let res1 = pos1 / pos2; + assert(res1 == I128::zero()); + + let res2 = pos2 / pos1; + assert(res2 == I128::try_from(U128::from((0, 2))).unwrap()); + + // First positive + let res3 = pos1 / neg1; + assert(res3 == I128::neg_try_from(U128::from((0, 1))).unwrap()); + + let res4 = pos2 / neg1; + assert(res4 == I128::neg_try_from(U128::from((0, 2))).unwrap()); + + let res5 = pos1 / neg2; + assert(res5 == I128::zero()); + + // Second positive + let res6 = neg1 / pos1; assert(res6 == I128::neg_try_from(U128::from((0, 1))).unwrap()); - // OrqEq Tests - let one_1 = I128::try_from(U128::from((0, 1))).unwrap(); - let one_2 = I128::try_from(U128::from((0, 1))).unwrap(); - let neg_one_1 = I128::neg_try_from(U128::from((0, 1))).unwrap(); - let neg_one_2 = I128::neg_try_from(U128::from((0, 1))).unwrap(); - let max_1 = I128::max(); - let max_2 = I128::max(); - let min_1 = I128::min(); - let min_2 = I128::min(); - - assert(one_1 >= one_2); - assert(one_1 <= one_2); - assert(neg_one_1 >= neg_one_2); - assert(neg_one_1 <= neg_one_2); - assert(max_1 >= max_1); - assert(max_1 <= max_1); - assert(min_1 >= min_1); - assert(min_1 <= min_1); - - assert(min_1 <= one_1); - assert(min_1 <= neg_one_1); - assert(min_1 <= max_1); - assert(neg_one_1 <= max_1); - assert(neg_one_1 <= one_1); - assert(one_1 <= max_1); - - assert(max_1 >= one_1); - assert(max_1 >= neg_one_1); - assert(max_1 >= min_1); - assert(one_1 >= neg_one_1); - assert(one_1 >= min_1); - assert(neg_one_1 >= min_1); - - // Test neg try from - let indent = I128::indent(); + let res7 = neg2 / pos1; + assert(res7 == I128::neg_try_from(U128::from((0, 2))).unwrap()); - let neg_try_from_zero = I128::neg_try_from(U128::min()); - assert(neg_try_from_zero.is_some()); - assert(neg_try_from_zero.unwrap() == I128::zero()); + let res8 = neg1 / pos2; + assert(res8 == I128::zero()); - let neg_try_from_one = I128::neg_try_from(U128::from((0, 1))); - assert(neg_try_from_one.is_some()); - assert(neg_try_from_one.unwrap().underlying() == I128::indent() - U128::from((0, 1))); + // Both negative + let res9 = neg1 / neg2; + assert(res9 == I128::zero()); - let neg_try_from_max = I128::neg_try_from(indent); - assert(neg_try_from_max.is_some()); - assert(neg_try_from_max.unwrap().underlying() == U128::min()); + let res10 = neg2 / neg1; + assert(res10 == I128::try_from(U128::from((0, 2))).unwrap()); - let neg_try_from_overflow = I128::neg_try_from(indent + U128::from((0, 1))); - assert(neg_try_from_overflow.is_none()); + // Edge Cases + let res12 = I128::zero() / I128::max(); + assert(res12 == I128::zero()); + + let res13 = I128::zero() / I128::min(); + assert(res13 == I128::zero()); +} + +#[test(should_revert)] +fn revert_signed_i128_divide() { + let zero = I128::zero(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i128_divide_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + let zero = I128::zero(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); + + let res = one / zero; + assert(res == I128::zero()); +} + +#[test(should_revert)] +fn revert_signed_i128_divide_disable_overflow() { + let _ = disable_panic_on_overflow(); + let zero = I128::zero(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i128_wrapping_neg() { + let one = I128::try_from(U128::from((0, 1))).unwrap(); + let neg_one = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let two = I128::try_from(U128::from((0, 2))).unwrap(); + let neg_two = I128::neg_try_from(U128::from((0, 2))).unwrap(); + let ten = I128::try_from(U128::from((0, 10))).unwrap(); + let neg_ten = I128::neg_try_from(U128::from((0, 10))).unwrap(); + let twenty_seven = I128::try_from(U128::from((0, 27))).unwrap(); + let neg_twenty_seven = I128::neg_try_from(U128::from((0, 27))).unwrap(); + let ninty_three = I128::try_from(U128::from((0, 93))).unwrap(); + let neg_ninty_three = I128::neg_try_from(U128::from((0, 93))).unwrap(); + let upper_u128 = I128::try_from(U128::from((1, 0))).unwrap(); + let neg_upper_u128 = I128::neg_try_from(U128::from((1, 0))).unwrap(); + let zero = I128::try_from(U128::from((0, 0))).unwrap(); + let max = I128::max(); + let min = I128::min(); + let neg_min_plus_one = I128::min() + I128::try_from(U128::from((0, 1))).unwrap(); + + let res1 = one.wrapping_neg(); + let res2 = neg_one.wrapping_neg(); + assert(res1 == neg_one); + assert(res2 == one); + + let res3 = two.wrapping_neg(); + let res4 = neg_two.wrapping_neg(); + assert(res3 == neg_two); + assert(res4 == two); + + let res5 = ten.wrapping_neg(); + let res6 = neg_ten.wrapping_neg(); + assert(res5 == neg_ten); + assert(res6 == ten); + + let res7 = twenty_seven.wrapping_neg(); + let res8 = neg_twenty_seven.wrapping_neg(); + assert(res7 == neg_twenty_seven); + assert(res8 == twenty_seven); + + let res9 = ninty_three.wrapping_neg(); + let res10 = neg_ninty_three.wrapping_neg(); + assert(res9 == neg_ninty_three); + assert(res10 == ninty_three); + + let res11 = zero.wrapping_neg(); + let res12 = max.wrapping_neg(); + let res13 = min.wrapping_neg(); + + let res14 = upper_u128.wrapping_neg(); + let res15 = neg_upper_u128.wrapping_neg(); + assert(res14 == neg_upper_u128); + assert(res15 == upper_u128); + + assert(res11 == zero); + assert(res12 == neg_min_plus_one); + assert(res13 == min); +} - // Test into I128 +#[test] +fn signed_i128_try_from_u128() { let indent: U128 = I128::indent(); - let i128_max_try_from = I128::try_from(indent); + let i128_max_try_from = I128::try_from(indent - U128::from((0, 1))); assert(i128_max_try_from.is_some()); assert(i128_max_try_from.unwrap() == I128::max()); @@ -126,28 +670,39 @@ fn main() -> bool { assert(i128_min_try_from.is_some()); assert(i128_min_try_from.unwrap() == I128::zero()); - let i128_overflow_try_from = I128::try_from(indent + U128::from((0, 1))); - assert(i128_overflow_try_from.is_none()); + let i128_overflow_try_from = I128::try_from(indent); + assert(i128_overflow_try_from.is_none()); +} - let i128_max_try_into: Option = indent.try_into(); - assert(i128_max_try_into.is_some()); - assert(i128_max_try_into.unwrap() == I128::max()); +#[test] +fn signed_i128_try_into_u128() { + let zero = I128::zero(); + let negative = I128::neg_try_from(U128::from((0, 1))).unwrap(); + let max = I128::max(); + let indent: U128 = I128::indent(); - let i128_min_try_into: Option = U128::min().try_into(); - assert(i128_min_try_into.is_some()); - assert(i128_min_try_into.unwrap() == I128::zero()); + let U128_max_try_into: Option = max.try_into(); + assert(U128_max_try_into.is_some()); + assert(U128_max_try_into.unwrap() == indent - U128::from((0, 1))); - let i128_overflow_try_into: Option = (indent + U128::from((0, 1))).try_into(); - assert(i128_overflow_try_into.is_none()); + let U128_min_try_into: Option = zero.try_into(); + assert(U128_min_try_into.is_some()); + assert(U128_min_try_into.unwrap() == U128::zero()); - // Test into U128 + let U128_overflow_try_into: Option = negative.try_into(); + assert(U128_overflow_try_into.is_none()); +} + +#[test] +fn signed_i128_u128_try_from() { let zero = I128::zero(); let negative = I128::neg_try_from(U128::from((0, 1))).unwrap(); let max = I128::max(); + let indent: U128 = I128::indent(); let U128_max_try_from: Option = U128::try_from(max); assert(U128_max_try_from.is_some()); - assert(U128_max_try_from.unwrap() == indent); + assert(U128_max_try_from.unwrap() == indent - U128::from((0, 1))); let U128_min_try_from: Option = U128::try_from(zero); assert(U128_min_try_from.is_some()); @@ -155,17 +710,20 @@ fn main() -> bool { let U128_overflow_try_from: Option = U128::try_from(negative); assert(U128_overflow_try_from.is_none()); +} - let U128_max_try_into: Option = zero.try_into(); - assert(U128_max_try_into.is_some()); - assert(U128_max_try_into.unwrap() == indent); +#[test] +fn signed_i128_u128_try_into() { + let indent: U128 = I128::indent(); - let U128_min_try_into: Option = zero.try_into(); - assert(U128_min_try_into.is_some()); - assert(U128_min_try_into.unwrap() == U128::zero()); + let i128_max_try_into: Option = (indent - U128::from((0, 1))).try_into(); + assert(i128_max_try_into.is_some()); + assert(i128_max_try_into.unwrap() == I128::max()); - let U128_overflow_try_into: Option = negative.try_into(); - assert(U128_overflow_try_into.is_none()); + let i128_min_try_into: Option = U128::min().try_into(); + assert(i128_min_try_into.is_some()); + assert(i128_min_try_into.unwrap() == I128::zero()); - true + let i128_overflow_try_into: Option = indent.try_into(); + assert(i128_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i128/tests/mod.rs b/tests/src/signed_integers/signed_i128/tests/mod.rs deleted file mode 100644 index 693fb25c..00000000 --- a/tests/src/signed_integers/signed_i128/tests/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi128", - abi = "src/signed_integers/signed_i128/out/release/i128_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i128_test_script() { - let path_to_bin = "src/signed_integers/signed_i128/out/release/i128_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi128::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} diff --git a/tests/src/signed_integers/signed_i128_wrapping_neg/.gitignore b/tests/src/signed_integers/signed_i128_wrapping_neg/.gitignore deleted file mode 100644 index 77d3844f..00000000 --- a/tests/src/signed_integers/signed_i128_wrapping_neg/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -out -target diff --git a/tests/src/signed_integers/signed_i128_wrapping_neg/Forc.toml b/tests/src/signed_integers/signed_i128_wrapping_neg/Forc.toml deleted file mode 100644 index 97be834a..00000000 --- a/tests/src/signed_integers/signed_i128_wrapping_neg/Forc.toml +++ /dev/null @@ -1,8 +0,0 @@ -[project] -authors = ["Fuel Labs "] -entry = "main.sw" -license = "Apache-2.0" -name = "i128_wrapping_neg_test" - -[dependencies] -sway_libs = { path = "../../../../libs" } diff --git a/tests/src/signed_integers/signed_i128_wrapping_neg/mod.rs b/tests/src/signed_integers/signed_i128_wrapping_neg/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i128_wrapping_neg/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw deleted file mode 100644 index 802d8705..00000000 --- a/tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw +++ /dev/null @@ -1,61 +0,0 @@ -script; - -use sway_libs::signed_integers::i128::I128; -use std::u128::U128; - -fn main() -> bool { - let one = I128::try_from(U128::from(1u64)).unwrap(); - let neg_one = I128::neg_try_from(U128::from(1u64)).unwrap(); - - let two = I128::try_from(U128::from(2u64)).unwrap(); - let neg_two = I128::neg_try_from(U128::from(2u64)).unwrap(); - - let ten = I128::try_from(U128::from(10u64)).unwrap(); - let neg_ten = I128::neg_try_from(U128::from(10u64)).unwrap(); - - let twenty_seven = I128::try_from(U128::from(27u64)).unwrap(); - let neg_twenty_seven = I128::neg_try_from(U128::from(27u64)).unwrap(); - - let ninty_three = I128::try_from(U128::from(93u64)).unwrap(); - let neg_ninty_three = I128::neg_try_from(U128::from(93u64)).unwrap(); - - let zero = I128::try_from(U128::zero()).unwrap(); - let max = I128::max(); - let min = I128::min(); - let neg_min_plus_one = I128::min() + I128::try_from(U128::from((0, 1))).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i128_wrapping_neg/tests/mod.rs b/tests/src/signed_integers/signed_i128_wrapping_neg/tests/mod.rs deleted file mode 100644 index 00132f65..00000000 --- a/tests/src/signed_integers/signed_i128_wrapping_neg/tests/mod.rs +++ /dev/null @@ -1,23 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi128WrappingNeg", - abi = - "src/signed_integers/signed_i128_wrapping_neg/out/release/i128_wrapping_neg_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i128_wrapping_neg_test_script() { - let path_to_bin = - "src/signed_integers/signed_i128_wrapping_neg/out/release/i128_wrapping_neg_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi128WrappingNeg::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} From e9d71273e8baefd343c14c182e0514aeca2bc99f Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:19:01 -0300 Subject: [PATCH 05/13] Add tests for i64 --- libs/src/signed_integers/i64.sw | 31 +- tests/src/signed_integers/signed_i64/mod.rs | 1 - .../signed_integers/signed_i64/src/main.sw | 669 +++++++++++++++--- .../signed_integers/signed_i64/tests/mod.rs | 21 - .../signed_i64_wrapping_neg/.gitignore | 2 - .../signed_i64_wrapping_neg/Forc.toml | 8 - .../signed_i64_wrapping_neg/mod.rs | 1 - .../signed_i64_wrapping_neg/src/main.sw | 60 -- .../signed_i64_wrapping_neg/tests/mod.rs | 22 - 9 files changed, 608 insertions(+), 207 deletions(-) delete mode 100644 tests/src/signed_integers/signed_i64/mod.rs delete mode 100644 tests/src/signed_integers/signed_i64/tests/mod.rs delete mode 100644 tests/src/signed_integers/signed_i64_wrapping_neg/.gitignore delete mode 100644 tests/src/signed_integers/signed_i64_wrapping_neg/Forc.toml delete mode 100644 tests/src/signed_integers/signed_i64_wrapping_neg/mod.rs delete mode 100644 tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i64_wrapping_neg/tests/mod.rs diff --git a/libs/src/signed_integers/i64.sw b/libs/src/signed_integers/i64.sw index 93e1ce2f..48866401 100644 --- a/libs/src/signed_integers/i64.sw +++ b/libs/src/signed_integers/i64.sw @@ -1,6 +1,6 @@ library; -use std::convert::TryFrom; +use std::{convert::{TryFrom, TryInto}, flags::panic_on_unsafe_math_enabled}; use ::signed_integers::common::WrappingNeg; use ::signed_integers::errors::Error; @@ -347,7 +347,10 @@ impl core::ops::Multiply for I64 { impl core::ops::Divide for I64 { /// Divide a I64 by a I64. Panics if divisor is zero. fn divide(self, divisor: Self) -> Self { - require(divisor != Self::new(), Error::ZeroDivisor); + if panic_on_unsafe_math_enabled() { + require(divisor != Self::new(), Error::ZeroDivisor); + } + let mut res = Self::new(); if self.underlying >= Self::indent() && divisor.underlying > Self::indent() @@ -394,7 +397,7 @@ impl WrappingNeg for I64 { impl TryFrom for I64 { fn try_from(value: u64) -> Option { // as the minimal value of I64 is -I64::indent() (1 << 63) we should add I64::indent() (1 << 63) - if value < u64::max() - Self::indent() { + if value < Self::indent() { Some(Self { underlying: value + Self::indent(), }) @@ -404,6 +407,16 @@ impl TryFrom for I64 { } } +impl TryInto for I64 { + fn try_into(self) -> Option { + if self.underlying >= Self::indent() { + Some(self.underlying - Self::indent()) + } else { + None + } + } +} + impl TryFrom for u64 { fn try_from(value: I64) -> Option { if value >= I64::zero() { @@ -413,3 +426,15 @@ impl TryFrom for u64 { } } } + +impl TryInto for u64 { + fn try_into(self) -> Option { + if self < I64::indent() { + Some(I64 { + underlying: self + I64::indent(), + }) + } else { + None + } + } +} diff --git a/tests/src/signed_integers/signed_i64/mod.rs b/tests/src/signed_integers/signed_i64/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i64/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i64/src/main.sw b/tests/src/signed_integers/signed_i64/src/main.sw index f6656df3..273cc039 100644 --- a/tests/src/signed_integers/signed_i64/src/main.sw +++ b/tests/src/signed_integers/signed_i64/src/main.sw @@ -1,28 +1,283 @@ -script; +library; use sway_libs::signed_integers::i64::I64; use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; -fn main() -> bool { +#[test] +fn signed_i64_indent() { + assert(I64::indent() == 9223372036854775808u64); +} + +#[test] +fn signed_i64_eq() { + let i64_1 = I64::zero(); + let i64_2 = I64::zero(); + let i64_3 = I64::try_from(1u64).unwrap(); + let i64_4 = I64::try_from(1u64).unwrap(); + let i64_5 = I64::max(); + let i64_6 = I64::max(); + let i64_7 = I64::min(); + let i64_8 = I64::min(); + let i64_9 = I64::neg_try_from(1u64).unwrap(); + let i64_10 = I64::neg_try_from(1u64).unwrap(); + + assert(i64_1 == i64_2); + assert(i64_3 == i64_4); + assert(i64_5 == i64_6); + assert(i64_7 == i64_8); + assert(i64_9 == i64_10); + + assert(i64_1 != i64_3); + assert(i64_1 != i64_5); + assert(i64_1 != i64_7); + assert(i64_1 != i64_9); + + assert(i64_3 != i64_5); + assert(i64_3 != i64_7); + assert(i64_3 != i64_9); + + assert(i64_5 != i64_7); + assert(i64_5 != i64_9); + + assert(i64_7 != i64_9); +} + +#[test] +fn signed_i64_ord() { + let i64_1 = I64::zero(); + let i64_2 = I64::zero(); + let i64_3 = I64::try_from(1u64).unwrap(); + let i64_4 = I64::try_from(1u64).unwrap(); + let i64_5 = I64::max(); + let i64_6 = I64::max(); + let i64_7 = I64::min(); + let i64_8 = I64::min(); + let i64_9 = I64::neg_try_from(1u64).unwrap(); + let i64_10 = I64::neg_try_from(1u64).unwrap(); + + assert(!(i64_1 > i64_2)); + assert(!(i64_3 > i64_4)); + assert(!(i64_5 > i64_6)); + assert(!(i64_7 > i64_8)); + assert(!(i64_9 > i64_10)); + + assert(i64_1 >= i64_2); + assert(i64_3 >= i64_4); + assert(i64_5 >= i64_6); + assert(i64_7 >= i64_8); + assert(i64_9 >= i64_10); + + assert(!(i64_1 < i64_2)); + assert(!(i64_3 < i64_4)); + assert(!(i64_5 < i64_6)); + assert(!(i64_7 < i64_8)); + assert(!(i64_9 < i64_10)); + + assert(i64_1 <= i64_2); + assert(i64_3 <= i64_4); + assert(i64_5 <= i64_6); + assert(i64_7 <= i64_8); + assert(i64_9 <= i64_10); + + assert(i64_1 < i64_3); + assert(i64_1 < i64_5); + assert(i64_3 < i64_5); + assert(i64_7 < i64_5); + assert(i64_9 < i64_5); + assert(i64_9 < i64_1); + assert(i64_9 < i64_3); + assert(i64_7 < i64_9); + + assert(i64_5 > i64_1); + assert(i64_5 > i64_3); + assert(i64_5 > i64_7); + assert(i64_5 > i64_9); + assert(i64_3 > i64_1); + assert(i64_3 > i64_7); + assert(i64_3 > i64_9); + assert(i64_9 > i64_7); +} + +#[test] +fn signed_i64_bits() { + assert(I64::bits() == 64); +} + +#[test] +fn signed_i64_from_uint() { + let zero = I64::from_uint(0u64); + let one = I64::from_uint(1u64); + let max = I64::from_uint(u64::max()); + + assert(zero.underlying() == 0u64); + assert(one.underlying() == 1u64); + assert(max.underlying() == u64::max()); +} + +#[test] +fn signed_i64_max() { + let max = I64::max(); + assert(max.underlying() == u64::max()); +} + +#[test] +fn signed_i64_min() { + let max = I64::min(); + assert(max.underlying() == u64::min()); +} + +#[test] +fn signed_i64_neg_try_from() { + let indent = I64::indent(); + + let neg_try_from_zero = I64::neg_try_from(u64::min()); + assert(neg_try_from_zero.is_some()); + assert(neg_try_from_zero.unwrap() == I64::zero()); + + let neg_try_from_one = I64::neg_try_from(1u64); + assert(neg_try_from_one.is_some()); + assert(neg_try_from_one.unwrap().underlying() == I64::indent() - 1u64); + + let neg_try_from_max = I64::neg_try_from(indent); + assert(neg_try_from_max.is_some()); + assert(neg_try_from_max.unwrap().underlying() == u64::min()); + + let neg_try_from_overflow = I64::neg_try_from(indent + 1u64); + assert(neg_try_from_overflow.is_none()); +} + +#[test] +fn signed_i64_new() { + let new = I64::new(); + + assert(new.underlying() == 9223372036854775808u64); +} + +#[test] +fn signed_i64_zero() { + let zero = I64::zero(); + + assert(zero.underlying() == 9223372036854775808u64); +} + +#[test] +fn signed_i64_is_zero() { + let zero = I64::zero(); + assert(zero.is_zero()); + + let other_1 = I64::from_uint(1); + let other_2 = I64::max(); + assert(!other_1.is_zero()); + assert(!other_2.is_zero()); +} + +#[test] +fn signed_i64_underlying() { + let zero = I64::from_uint(0u64); + let one = I64::from_uint(1u64); + let max = I64::from_uint(u64::max()); + let indent = I64::zero(); + + assert(zero.underlying() == 0u64); + assert(one.underlying() == 1u64); + assert(max.underlying() == u64::max()); + assert(indent.underlying() == 9223372036854775808u64); +} + +#[test] +fn signed_i64_add() { + let pos1 = I64::try_from(1).unwrap(); + let pos2 = I64::try_from(2).unwrap(); + let neg1 = I64::neg_try_from(1).unwrap(); + let neg2 = I64::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 + pos2; + assert(res1 == I64::try_from(3).unwrap()); + + let res2 = pos2 + pos1; + assert(res2 == I64::try_from(3).unwrap()); + + // First positive + let res3 = pos1 + neg1; + assert(res3 == I64::zero()); + + let res4 = pos2 + neg1; + assert(res4 == I64::try_from(1).unwrap()); + + let res5 = pos1 + neg2; + assert(res5 == I64::neg_try_from(1).unwrap()); + + // Second positive + let res6 = neg1 + pos1; + assert(res6 == I64::zero()); + + let res7 = neg2 + pos1; + assert(res7 == I64::neg_try_from(1).unwrap()); + + let res8 = neg1 + pos2; + assert(res8 == I64::try_from(1).unwrap()); + + // Both negative + let res9 = neg1 + neg2; + assert(res9 == I64::neg_try_from(3).unwrap()); + + let res10 = neg2 + neg1; + assert(res10 == I64::neg_try_from(3).unwrap()); + + // Edge Cases + let res11 = I64::min() + I64::max(); + assert(res11 == I64::neg_try_from(1).unwrap()); + + let res12 = I64::max() + I64::zero(); + assert(res12 == I64::max()); + + let res13 = I64::min() + I64::zero(); + assert(res13 == I64::min()); + + let res14 = I64::zero() + I64::zero(); + assert(res14 == I64::zero()); +} + +#[test(should_revert)] +fn revert_signed_i64_add() { let one = I64::try_from(1u64).unwrap(); - let mut res = one + I64::try_from(1u64).unwrap(); - assert(res == I64::try_from(2u64).unwrap()); + let max = I64::max(); + + let _ = max + one; +} - res = I64::try_from(10u64).unwrap() - I64::try_from(11u64).unwrap(); - assert(res == I64::try_from(9223372036854775807u64).unwrap()); - res = I64::try_from(10u64).unwrap() * I64::neg_try_from(1).unwrap(); - assert(res == I64::neg_try_from(10).unwrap()); +#[test(should_revert)] +fn revert_signed_i64_add_negative() { + let neg_one = I64::neg_try_from(1u64).unwrap(); + let min = I64::min(); + + let _ = min + neg_one; +} - res = I64::try_from(10u64).unwrap() * I64::try_from(10u64).unwrap(); - assert(res == I64::try_from(100u64).unwrap()); +#[test(should_revert)] +fn revert_signed_i64_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); - res = I64::try_from(10u64).unwrap() / I64::try_from(9223372036854775807u64).unwrap(); - assert(res == I64::neg_try_from(10u64).unwrap()); + let one = I64::try_from(1u64).unwrap(); + let max = I64::max(); + + let _ = max + one; +} - res = I64::try_from(10u64).unwrap() / I64::try_from(5u64).unwrap(); - assert(res == I64::try_from(2u64).unwrap()); +#[test] +fn signed_i64_add_overflow() { + let _ = disable_panic_on_overflow(); + + let one = I64::try_from(1u64).unwrap(); + let max = I64::max(); + + assert(max + one == I64::min()); +} - // Subtraction Tests +#[test] +fn signed_i64_subtract() { let pos1 = I64::try_from(1).unwrap(); let pos2 = I64::try_from(2).unwrap(); let neg1 = I64::neg_try_from(1).unwrap(); @@ -30,7 +285,6 @@ fn main() -> bool { // Both positive: let res1 = pos1 - pos2; - let res1_2 = pos2 - pos1; assert(res1 == I64::neg_try_from(1).unwrap()); let res2 = pos2 - pos1; @@ -40,72 +294,295 @@ fn main() -> bool { let res3 = pos1 - neg1; assert(res3 == I64::try_from(2).unwrap()); + let res4 = pos2 - neg1; + assert(res4 == I64::try_from(3).unwrap()); + // Second positive - let res4 = neg1 - pos1; + let res5 = neg1 - pos1; + assert(res5 == I64::neg_try_from(2).unwrap()); + + let res6 = neg2 - pos1; + assert(res6 == I64::neg_try_from(3).unwrap()); + + // Both negative + let res7 = neg1 - neg2; + assert(res7 == I64::try_from(1).unwrap()); + + let res8 = neg2 - neg1; + assert(res8 == I64::neg_try_from(1).unwrap()); + + // Edge Cases + let res11 = I64::zero() - (I64::min() + I64::try_from(1).unwrap()); + assert(res11 == I64::max()); + + let res12 = I64::max() - I64::zero(); + assert(res12 == I64::max()); + + let res13 = I64::min() - I64::zero(); + assert(res13 == I64::min()); + + let res14 = I64::zero() - I64::zero(); + assert(res14 == I64::zero()); +} + +#[test(should_revert)] +fn revert_signed_i64_sub() { + let min = I64::min(); + let one = I64::try_from(1u64).unwrap(); + + let _ = min - one; +} + +#[test(should_revert)] +fn revert_signed_i64_sub_negative() { + let max = I64::max(); + let neg_one = I64::neg_try_from(1u64).unwrap(); + + let _ = max - neg_one; +} + +#[test(should_revert)] +fn revert_signed_i64_sub_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let min = I64::min(); + let one = I64::try_from(1u64).unwrap(); + + let _ = min - one; +} + +#[test] +fn signed_i64_sub_underflow() { + let _ = disable_panic_on_overflow(); + + let min = I64::min(); + let one = I64::try_from(1u64).unwrap(); + + let result = min - one; + assert(result == I64::max()); +} + +#[test] +fn signed_i64_multiply() { + let pos1 = I64::try_from(1).unwrap(); + let pos2 = I64::try_from(2).unwrap(); + let neg1 = I64::neg_try_from(1).unwrap(); + let neg2 = I64::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 * pos2; + assert(res1 == I64::try_from(2).unwrap()); + + let res2 = pos2 * pos1; + assert(res2 == I64::try_from(2).unwrap()); + + // First positive + let res3 = pos1 * neg1; + assert(res3 == I64::neg_try_from(1).unwrap()); + + let res4 = pos2 * neg1; assert(res4 == I64::neg_try_from(2).unwrap()); + let res5 = pos1 * neg2; + assert(res5 == I64::neg_try_from(2).unwrap()); + + // Second positive + let res6 = neg1 * pos1; + assert(res6 == I64::neg_try_from(1).unwrap()); + + let res7 = neg2 * pos1; + assert(res7 == I64::neg_try_from(2).unwrap()); + + let res8 = neg1 * pos2; + assert(res8 == I64::neg_try_from(2).unwrap()); + // Both negative - let res5 = neg1 - neg2; - assert(res5 == I64::try_from(1).unwrap()); + let res9 = neg1 * neg2; + assert(res9 == I64::try_from(2).unwrap()); + + let res10 = neg2 * neg1; + assert(res10 == I64::try_from(2).unwrap()); + + // Edge Cases + let res12 = I64::max() * I64::zero(); + assert(res12 == I64::zero()); + + let res13 = I64::min() * I64::zero(); + assert(res13 == I64::zero()); + + let res14 = I64::zero() * I64::zero(); + assert(res14 == I64::zero()); +} + +#[test(should_revert)] +fn revert_signed_i64_mul() { + let max = I64::max(); + let two = I64::try_from(2u64).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i64_mul_negatice() { + let max = I64::max(); + let two = I64::neg_try_from(2u64).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i64_mul_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let max = I64::max(); + let two = I64::try_from(2u64).unwrap(); + + let _ = max * two; +} + +#[test] +fn signed_i64_mul() { + let _ = disable_panic_on_overflow(); - let res6 = neg2 - neg1; + let max = I64::max(); + let two = I64::try_from(2u64).unwrap(); + + let result = max * two; + assert(result == I64::neg_try_from(2).unwrap()); +} + +#[test] +fn signed_i64_divide() { + let pos1 = I64::try_from(1).unwrap(); + let pos2 = I64::try_from(2).unwrap(); + let neg1 = I64::neg_try_from(1).unwrap(); + let neg2 = I64::neg_try_from(2).unwrap(); + + // Both positive: + let res1 = pos1 / pos2; + assert(res1 == I64::zero()); + + let res2 = pos2 / pos1; + assert(res2 == I64::try_from(2).unwrap()); + + // First positive + let res3 = pos1 / neg1; + assert(res3 == I64::neg_try_from(1).unwrap()); + + let res4 = pos2 / neg1; + assert(res4 == I64::neg_try_from(2).unwrap()); + + let res5 = pos1 / neg2; + assert(res5 == I64::zero()); + + // Second positive + let res6 = neg1 / pos1; assert(res6 == I64::neg_try_from(1).unwrap()); - // OrqEq Tests - let one_1 = I64::try_from(1u64).unwrap(); - let one_2 = I64::try_from(1u64).unwrap(); - let neg_one_1 = I64::neg_try_from(1u64).unwrap(); - let neg_one_2 = I64::neg_try_from(1u64).unwrap(); - let max_1 = I64::max(); - let max_2 = I64::max(); - let min_1 = I64::min(); - let min_2 = I64::min(); - - assert(one_1 >= one_2); - assert(one_1 <= one_2); - assert(neg_one_1 >= neg_one_2); - assert(neg_one_1 <= neg_one_2); - assert(max_1 >= max_1); - assert(max_1 <= max_1); - assert(min_1 >= min_1); - assert(min_1 <= min_1); - - assert(min_1 <= one_1); - assert(min_1 <= neg_one_1); - assert(min_1 <= max_1); - assert(neg_one_1 <= max_1); - assert(neg_one_1 <= one_1); - assert(one_1 <= max_1); - - assert(max_1 >= one_1); - assert(max_1 >= neg_one_1); - assert(max_1 >= min_1); - assert(one_1 >= neg_one_1); - assert(one_1 >= min_1); - assert(neg_one_1 >= min_1); - - // Test neg try from - let indent = I64::indent(); + let res7 = neg2 / pos1; + assert(res7 == I64::neg_try_from(2).unwrap()); - let neg_try_from_zero = I64::neg_try_from(u64::min()); - assert(neg_try_from_zero.is_some()); - assert(neg_try_from_zero.unwrap() == I64::zero()); + let res8 = neg1 / pos2; + assert(res8 == I64::zero()); - let neg_try_from_one = I64::neg_try_from(1u64); - assert(neg_try_from_one.is_some()); - assert(neg_try_from_one.unwrap().underlying() == I64::indent() - 1u64); + // Both negative + let res9 = neg1 / neg2; + assert(res9 == I64::zero()); - let neg_try_from_max = I64::neg_try_from(indent); - assert(neg_try_from_max.is_some()); - assert(neg_try_from_max.unwrap().underlying() == u64::min()); + let res10 = neg2 / neg1; + assert(res10 == I64::try_from(2).unwrap()); - let neg_try_from_overflow = I64::neg_try_from(indent + 1u64); - assert(neg_try_from_overflow.is_none()); + // Edge Cases + let res12 = I64::zero() / I64::max(); + assert(res12 == I64::zero()); + + let res13 = I64::zero() / I64::min(); + assert(res13 == I64::zero()); +} - // Test into I64 +#[test(should_revert)] +fn revert_signed_i64_divide() { + let zero = I64::zero(); + let one = I64::try_from(1u64).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i64_divide_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + let zero = I64::zero(); + let one = I64::try_from(1u64).unwrap(); + + let res = one / zero; + assert(res == I64::zero()); +} + +#[test(should_revert)] +fn revert_signed_i64_divide_disable_overflow() { + let _ = disable_panic_on_overflow(); + let zero = I64::zero(); + let one = I64::try_from(1u64).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i64_wrapping_neg() { + let one = I64::try_from(1u64).unwrap(); + let neg_one = I64::neg_try_from(1u64).unwrap(); + let two = I64::try_from(2u64).unwrap(); + let neg_two = I64::neg_try_from(2u64).unwrap(); + let ten = I64::try_from(10u64).unwrap(); + let neg_ten = I64::neg_try_from(10u64).unwrap(); + let twenty_seven = I64::try_from(27u64).unwrap(); + let neg_twenty_seven = I64::neg_try_from(27u64).unwrap(); + let ninty_three = I64::try_from(93u64).unwrap(); + let neg_ninty_three = I64::neg_try_from(93u64).unwrap(); + let zero = I64::try_from(0u64).unwrap(); + let max = I64::max(); + let min = I64::min(); + let neg_min_plus_one = I64::min() + I64::try_from(1u64).unwrap(); + + let res1 = one.wrapping_neg(); + let res2 = neg_one.wrapping_neg(); + assert(res1 == neg_one); + assert(res2 == one); + + let res3 = two.wrapping_neg(); + let res4 = neg_two.wrapping_neg(); + assert(res3 == neg_two); + assert(res4 == two); + + let res5 = ten.wrapping_neg(); + let res6 = neg_ten.wrapping_neg(); + assert(res5 == neg_ten); + assert(res6 == ten); + + let res7 = twenty_seven.wrapping_neg(); + let res8 = neg_twenty_seven.wrapping_neg(); + assert(res7 == neg_twenty_seven); + assert(res8 == twenty_seven); + + let res9 = ninty_three.wrapping_neg(); + let res10 = neg_ninty_three.wrapping_neg(); + assert(res9 == neg_ninty_three); + assert(res10 == ninty_three); + + let res11 = zero.wrapping_neg(); + let res12 = max.wrapping_neg(); + let res13 = min.wrapping_neg(); + + assert(res11 == zero); + assert(res12 == neg_min_plus_one); + assert(res13 == min); +} + +#[test] +fn signed_i64_try_from_u64() { let indent: u64 = I64::indent(); - let i64_max_try_from = I64::try_from(indent); + let i64_max_try_from = I64::try_from(indent - 1); assert(i64_max_try_from.is_some()); assert(i64_max_try_from.unwrap() == I64::max()); @@ -113,28 +590,39 @@ fn main() -> bool { assert(i64_min_try_from.is_some()); assert(i64_min_try_from.unwrap() == I64::zero()); - let i64_overflow_try_from = I64::try_from(indent + 1); - assert(i64_overflow_try_from.is_none()); + let i64_overflow_try_from = I64::try_from(indent); + assert(i64_overflow_try_from.is_none()); +} - let i64_max_try_into: Option = indent.try_into(); - assert(i64_max_try_into.is_some()); - assert(i64_max_try_into.unwrap() == I64::max()); +#[test] +fn signed_i64_try_into_u64() { + let zero = I64::zero(); + let negative = I64::neg_try_from(1).unwrap(); + let max = I64::max(); + let indent: u64 = I64::indent(); - let i64_min_try_into: Option = u64::min().try_into(); - assert(i64_min_try_into.is_some()); - assert(i64_min_try_into.unwrap() == I64::zero()); + let u64_max_try_into: Option = max.try_into(); + assert(u64_max_try_into.is_some()); + assert(u64_max_try_into.unwrap() == indent - 1); - let i64_overflow_try_into: Option = (indent + 1).try_into(); - assert(i64_overflow_try_into.is_none()); + let u64_min_try_into: Option = zero.try_into(); + assert(u64_min_try_into.is_some()); + assert(u64_min_try_into.unwrap() == u64::zero()); - // Test into u64 + let u64_overflow_try_into: Option = negative.try_into(); + assert(u64_overflow_try_into.is_none()); +} + +#[test] +fn signed_i64_u64_try_from() { let zero = I64::zero(); let negative = I64::neg_try_from(1).unwrap(); let max = I64::max(); + let indent: u64 = I64::indent(); let u64_max_try_from: Option = u64::try_from(max); assert(u64_max_try_from.is_some()); - assert(u64_max_try_from.unwrap() == indent); + assert(u64_max_try_from.unwrap() == indent - 1); let u64_min_try_from: Option = u64::try_from(zero); assert(u64_min_try_from.is_some()); @@ -142,17 +630,20 @@ fn main() -> bool { let u64_overflow_try_from: Option = u64::try_from(negative); assert(u64_overflow_try_from.is_none()); +} - let u64_max_try_into: Option = zero.try_into(); - assert(u64_max_try_into.is_some()); - assert(u64_max_try_into.unwrap() == indent); +#[test] +fn signed_i64_u64_try_into() { + let indent: u64 = I64::indent(); - let u64_min_try_into: Option = zero.try_into(); - assert(u64_min_try_into.is_some()); - assert(u64_min_try_into.unwrap() == u64::zero()); + let i64_max_try_into: Option = (indent - 1).try_into(); + assert(i64_max_try_into.is_some()); + assert(i64_max_try_into.unwrap() == I64::max()); - let u64_overflow_try_into: Option = negative.try_into(); - assert(u64_overflow_try_into.is_none()); + let i64_min_try_into: Option = u64::min().try_into(); + assert(i64_min_try_into.is_some()); + assert(i64_min_try_into.unwrap() == I64::zero()); - true + let i64_overflow_try_into: Option = indent.try_into(); + assert(i64_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i64/tests/mod.rs b/tests/src/signed_integers/signed_i64/tests/mod.rs deleted file mode 100644 index ed3729ec..00000000 --- a/tests/src/signed_integers/signed_i64/tests/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi64", - abi = "src/signed_integers/signed_i64/out/release/i64_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i64_test_script() { - let path_to_bin = "src/signed_integers/signed_i64/out/release/i64_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi64::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} diff --git a/tests/src/signed_integers/signed_i64_wrapping_neg/.gitignore b/tests/src/signed_integers/signed_i64_wrapping_neg/.gitignore deleted file mode 100644 index 77d3844f..00000000 --- a/tests/src/signed_integers/signed_i64_wrapping_neg/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -out -target diff --git a/tests/src/signed_integers/signed_i64_wrapping_neg/Forc.toml b/tests/src/signed_integers/signed_i64_wrapping_neg/Forc.toml deleted file mode 100644 index ffeb52f3..00000000 --- a/tests/src/signed_integers/signed_i64_wrapping_neg/Forc.toml +++ /dev/null @@ -1,8 +0,0 @@ -[project] -authors = ["Fuel Labs "] -entry = "main.sw" -license = "Apache-2.0" -name = "i64_wrapping_neg_test" - -[dependencies] -sway_libs = { path = "../../../../libs" } diff --git a/tests/src/signed_integers/signed_i64_wrapping_neg/mod.rs b/tests/src/signed_integers/signed_i64_wrapping_neg/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i64_wrapping_neg/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw deleted file mode 100644 index e76f4d5c..00000000 --- a/tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i64::I64; - -fn main() -> bool { - let one = I64::try_from(1u64).unwrap(); - let neg_one = I64::neg_try_from(1u64).unwrap(); - - let two = I64::try_from(2u64).unwrap(); - let neg_two = I64::neg_try_from(2u64).unwrap(); - - let ten = I64::try_from(10u64).unwrap(); - let neg_ten = I64::neg_try_from(10u64).unwrap(); - - let twenty_seven = I64::try_from(27u64).unwrap(); - let neg_twenty_seven = I64::neg_try_from(27u64).unwrap(); - - let ninty_three = I64::try_from(93u64).unwrap(); - let neg_ninty_three = I64::neg_try_from(93u64).unwrap(); - - let zero = I64::try_from(0u64).unwrap(); - let max = I64::max(); - let min = I64::min(); - let neg_min_plus_one = I64::min() + I64::try_from(1).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i64_wrapping_neg/tests/mod.rs b/tests/src/signed_integers/signed_i64_wrapping_neg/tests/mod.rs deleted file mode 100644 index a2754493..00000000 --- a/tests/src/signed_integers/signed_i64_wrapping_neg/tests/mod.rs +++ /dev/null @@ -1,22 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi64WrappingNeg", - abi = "src/signed_integers/signed_i64_wrapping_neg/out/release/i64_wrapping_neg_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i64_wrapping_neg_test_script() { - let path_to_bin = - "src/signed_integers/signed_i64_wrapping_neg/out/release/i64_wrapping_neg_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi64WrappingNeg::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} From 52183f90bacf51ebe7ce6ab600bbb935cf5e352c Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:19:13 -0300 Subject: [PATCH 06/13] Add tests for i256 --- libs/src/signed_integers/i256.sw | 31 +- tests/Forc.lock | 52 +- tests/Forc.toml | 6 - tests/src/harness.rs | 1 - tests/src/signed_integers/mod.rs | 12 - tests/src/signed_integers/signed_i256/mod.rs | 1 - .../signed_integers/signed_i256/src/main.sw | 749 ++++++++++++++---- .../signed_integers/signed_i256/tests/mod.rs | 21 - .../signed_i256_wrapping_neg/.gitignore | 2 - .../signed_i256_wrapping_neg/Forc.toml | 8 - .../signed_i256_wrapping_neg/mod.rs | 1 - .../signed_i256_wrapping_neg/src/main.sw | 81 -- .../signed_i256_wrapping_neg/tests/mod.rs | 23 - 13 files changed, 627 insertions(+), 361 deletions(-) delete mode 100644 tests/src/signed_integers/mod.rs delete mode 100644 tests/src/signed_integers/signed_i256/mod.rs delete mode 100644 tests/src/signed_integers/signed_i256/tests/mod.rs delete mode 100644 tests/src/signed_integers/signed_i256_wrapping_neg/.gitignore delete mode 100644 tests/src/signed_integers/signed_i256_wrapping_neg/Forc.toml delete mode 100644 tests/src/signed_integers/signed_i256_wrapping_neg/mod.rs delete mode 100644 tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i256_wrapping_neg/tests/mod.rs diff --git a/libs/src/signed_integers/i256.sw b/libs/src/signed_integers/i256.sw index 70720a11..c75bda07 100644 --- a/libs/src/signed_integers/i256.sw +++ b/libs/src/signed_integers/i256.sw @@ -1,6 +1,6 @@ library; -use std::convert::TryFrom; +use std::{convert::{TryFrom, TryInto}, flags::panic_on_unsafe_math_enabled}; use ::signed_integers::common::WrappingNeg; use ::signed_integers::errors::Error; @@ -292,7 +292,10 @@ impl core::ops::Add for I256 { impl core::ops::Divide for I256 { /// Divide a I256 by a I256. Panics if divisor is zero. fn divide(self, divisor: Self) -> Self { - require(divisor != Self::new(), Error::ZeroDivisor); + if panic_on_unsafe_math_enabled() { + require(divisor != Self::new(), Error::ZeroDivisor); + } + let mut res = Self::new(); let indent = Self::indent(); @@ -384,7 +387,7 @@ impl WrappingNeg for I256 { impl TryFrom for I256 { fn try_from(value: u256) -> Option { // as the minimal value of I256 is -I256::indent() (1 << 63) we should add I256::indent() (1 << 63) - if value < u256::max() - Self::indent() { + if value < Self::indent() { Some(Self { underlying: value + Self::indent(), }) @@ -394,6 +397,16 @@ impl TryFrom for I256 { } } +impl TryInto for I256 { + fn try_into(self) -> Option { + if self.underlying >= Self::indent() { + Some(self.underlying - Self::indent()) + } else { + None + } + } +} + impl TryFrom for u256 { fn try_from(value: I256) -> Option { if value >= I256::zero() { @@ -403,3 +416,15 @@ impl TryFrom for u256 { } } } + +impl TryInto for u256 { + fn try_into(self) -> Option { + if self < I256::indent() { + Some(I256 { + underlying: self + I256::indent(), + }) + } else { + None + } + } +} diff --git a/tests/Forc.lock b/tests/Forc.lock index a94a102b..d138d37f 100644 --- a/tests/Forc.lock +++ b/tests/Forc.lock @@ -30,7 +30,7 @@ dependencies = ["std"] [[package]] name = "core" -source = "path+from-root-DD4F12EBC39CAB5B" +source = "path+from-root-2005F6931E5DB2F8" [[package]] name = "i128_test" @@ -40,14 +40,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i128_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i16_test" source = "member" @@ -56,14 +48,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i16_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i256_test" source = "member" @@ -72,14 +56,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i256_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i32_test" source = "member" @@ -88,14 +64,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i32_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i64_test" source = "member" @@ -104,14 +72,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i64_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i8_test" source = "member" @@ -120,14 +80,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i8_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "merkle_proof_test" source = "member" @@ -252,7 +204,7 @@ dependencies = ["std"] [[package]] name = "std" -source = "git+https://github.com/fuellabs/sway?tag=v0.66.7#5ed7cec6dbcd42f0c2f84df8511a4c0007b1902e" +source = "git+https://github.com/fuellabs/sway?rev#be5ecbd69249aa62eaa5fd7fb6c5bee347956b69" dependencies = ["core"] [[package]] diff --git a/tests/Forc.toml b/tests/Forc.toml index 5c06f17a..438aa88e 100644 --- a/tests/Forc.toml +++ b/tests/Forc.toml @@ -23,12 +23,6 @@ members = [ "./src/signed_integers/signed_i64", "./src/signed_integers/signed_i128", "./src/signed_integers/signed_i256", - "./src/signed_integers/signed_i8_wrapping_neg", - "./src/signed_integers/signed_i16_wrapping_neg", - "./src/signed_integers/signed_i32_wrapping_neg", - "./src/signed_integers/signed_i64_wrapping_neg", - "./src/signed_integers/signed_i128_wrapping_neg", - "./src/signed_integers/signed_i256_wrapping_neg", "./src/upgradability", "./src/bigint", ] diff --git a/tests/src/harness.rs b/tests/src/harness.rs index 7ae34127..9b1a56ad 100644 --- a/tests/src/harness.rs +++ b/tests/src/harness.rs @@ -5,5 +5,4 @@ mod merkle_proof; mod native_asset; mod ownership; mod reentrancy; -mod signed_integers; mod upgradability; diff --git a/tests/src/signed_integers/mod.rs b/tests/src/signed_integers/mod.rs deleted file mode 100644 index e969e9d5..00000000 --- a/tests/src/signed_integers/mod.rs +++ /dev/null @@ -1,12 +0,0 @@ -mod signed_i128; -mod signed_i128_wrapping_neg; -mod signed_i16; -mod signed_i16_wrapping_neg; -mod signed_i256; -mod signed_i256_wrapping_neg; -mod signed_i32; -mod signed_i32_wrapping_neg; -mod signed_i64; -mod signed_i64_wrapping_neg; -mod signed_i8; -mod signed_i8_wrapping_neg; diff --git a/tests/src/signed_integers/signed_i256/mod.rs b/tests/src/signed_integers/signed_i256/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i256/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i256/src/main.sw b/tests/src/signed_integers/signed_i256/src/main.sw index 1b6cf600..7c602739 100644 --- a/tests/src/signed_integers/signed_i256/src/main.sw +++ b/tests/src/signed_integers/signed_i256/src/main.sw @@ -1,157 +1,588 @@ -script; +library; -use std::convert::*; use sway_libs::signed_integers::i256::I256; +use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; -fn main() -> bool { - let parts_one = (0, 0, 0, 1); - let parts_two = (0, 0, 0, 2); - let u256_one = asm(r1: parts_one) { - r1: u256 - }; - let u256_two = asm(r1: parts_two) { - r1: u256 - }; - - let one = I256::try_from(u256_one).unwrap(); - let mut res = one + I256::try_from(u256_one).unwrap(); - assert(res == I256::try_from(u256_two).unwrap()); - - let parts_10 = (0, 0, 0, 10); - let u256_10 = asm(r1: parts_10) { - r1: u256 - }; - - let parts_11 = (0, 0, 0, 11); - let u256_11 = asm(r1: parts_11) { - r1: u256 - }; - - res = I256::try_from(u256_10).unwrap() - I256::try_from(u256_11).unwrap(); - let (a, b, c, d) = asm(r1: res) { - r1: (u64, u64, u64, u64) - }; - assert(c == u64::max()); - assert(d == u64::max()); - - res = I256::try_from(u256_10).unwrap() * I256::neg_try_from(u256_one).unwrap(); - assert(res == I256::neg_try_from(u256_10).unwrap()); - - res = I256::try_from(u256_10).unwrap() * I256::try_from(u256_10).unwrap(); - let parts_100 = (0, 0, 0, 100); - let u256_100 = asm(r1: parts_100) { - r1: u256 - }; - assert(res == I256::try_from(u256_100).unwrap()); - - let parts_lower_max_u64 = (0, 0, 0, u64::max()); - let u256_lower_max_u64 = asm(r1: parts_lower_max_u64) { - r1: u256 - }; - - res = I256::try_from(u256_10).unwrap() / I256::try_from(u256_lower_max_u64).unwrap(); - assert(res == I256::neg_try_from(u256_10).unwrap()); - - let parts_5 = (0, 0, 0, 5); - let u256_5 = asm(r1: parts_5) { - r1: u256 - }; - - let parts_2 = (0, 0, 0, 2); - let u256_2 = asm(r1: parts_2) { - r1: u256 - }; - - let i256_10 = I256::try_from(u256_10).unwrap(); - let i256_5 = I256::try_from(u256_5).unwrap(); - let i256_2 = I256::try_from(u256_2).unwrap(); - - res = i256_10 / i256_5; - assert(res == i256_2); - - // Subtraction tests - let pos1 = I256::try_from(u256_one).unwrap(); - let pos2 = I256::try_from(u256_two).unwrap(); - let neg1 = I256::neg_try_from(u256_one).unwrap(); - let neg2 = I256::neg_try_from(u256_two).unwrap(); +#[test] +fn signed_i256_indent() { + assert(I256::indent() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); +} - // Both positive: - let res1 = pos1 - pos2; - assert(res1 == I256::neg_try_from(u256_one).unwrap()); +#[test] +fn signed_i256_eq() { + let i256_1 = I256::zero(); + let i256_2 = I256::zero(); + let i256_3 = I256::try_from(0x1u256).unwrap(); + let i256_4 = I256::try_from(0x1u256).unwrap(); + let i256_5 = I256::max(); + let i256_6 = I256::max(); + let i256_7 = I256::min(); + let i256_8 = I256::min(); + let i256_9 = I256::neg_try_from(0x1u256).unwrap(); + let i256_10 = I256::neg_try_from(0x1u256).unwrap(); + + assert(i256_1 == i256_2); + assert(i256_3 == i256_4); + assert(i256_5 == i256_6); + assert(i256_7 == i256_8); + assert(i256_9 == i256_10); + + assert(i256_1 != i256_3); + assert(i256_1 != i256_5); + assert(i256_1 != i256_7); + assert(i256_1 != i256_9); + + assert(i256_3 != i256_5); + assert(i256_3 != i256_7); + assert(i256_3 != i256_9); + + assert(i256_5 != i256_7); + assert(i256_5 != i256_9); + + assert(i256_7 != i256_9); +} - let res2 = pos2 - pos1; - assert(res2 == I256::try_from(u256_one).unwrap()); +#[test] +fn signed_i256_ord() { + let i256_1 = I256::zero(); + let i256_2 = I256::zero(); + let i256_3 = I256::try_from(0x1u256).unwrap(); + let i256_4 = I256::try_from(0x1u256).unwrap(); + let i256_5 = I256::max(); + let i256_6 = I256::max(); + let i256_7 = I256::min(); + let i256_8 = I256::min(); + let i256_9 = I256::neg_try_from(0x1u256).unwrap(); + let i256_10 = I256::neg_try_from(0x1u256).unwrap(); + + assert(!(i256_1 > i256_2)); + assert(!(i256_3 > i256_4)); + assert(!(i256_5 > i256_6)); + assert(!(i256_7 > i256_8)); + assert(!(i256_9 > i256_10)); + + assert(i256_1 >= i256_2); + assert(i256_3 >= i256_4); + assert(i256_5 >= i256_6); + assert(i256_7 >= i256_8); + assert(i256_9 >= i256_10); + + assert(!(i256_1 < i256_2)); + assert(!(i256_3 < i256_4)); + assert(!(i256_5 < i256_6)); + assert(!(i256_7 < i256_8)); + assert(!(i256_9 < i256_10)); + + assert(i256_1 <= i256_2); + assert(i256_3 <= i256_4); + assert(i256_5 <= i256_6); + assert(i256_7 <= i256_8); + assert(i256_9 <= i256_10); + + assert(i256_1 < i256_3); + assert(i256_1 < i256_5); + assert(i256_3 < i256_5); + assert(i256_7 < i256_5); + assert(i256_9 < i256_5); + assert(i256_9 < i256_1); + assert(i256_9 < i256_3); + assert(i256_7 < i256_9); + + assert(i256_5 > i256_1); + assert(i256_5 > i256_3); + assert(i256_5 > i256_7); + assert(i256_5 > i256_9); + assert(i256_3 > i256_1); + assert(i256_3 > i256_7); + assert(i256_3 > i256_9); + assert(i256_9 > i256_7); +} - // First positive - let res3 = pos1 - neg1; - assert(res3 == I256::try_from(u256_two).unwrap()); +#[test] +fn signed_i256_bits() { + assert(I256::bits() == 256); +} - // Second positive - let res4 = neg1 - pos1; - assert(res4 == I256::neg_try_from(u256_two).unwrap()); +#[test] +fn signed_i256_from_uint() { + let zero = I256::from_uint(u256::zero()); + let one = I256::from_uint(0x1u256); + let max = I256::from_uint(u256::max()); - // Both negative - let res5 = neg1 - neg2; - assert(res5 == I256::try_from(u256_one).unwrap()); - - let res6 = neg2 - neg1; - assert(res6 == I256::neg_try_from(u256_one).unwrap()); - - // OrqEq Tests - let one_1 = I256::try_from(u256_one).unwrap(); - let one_2 = I256::try_from(u256_one).unwrap(); - let neg_one_1 = I256::neg_try_from(u256_one).unwrap(); - let neg_one_2 = I256::neg_try_from(u256_one).unwrap(); - let max_1 = I256::max(); - let max_2 = I256::max(); - let min_1 = I256::min(); - let min_2 = I256::min(); - - assert(one_1 >= one_2); - assert(one_1 <= one_2); - assert(neg_one_1 >= neg_one_2); - assert(neg_one_1 <= neg_one_2); - assert(max_1 >= max_1); - assert(max_1 <= max_1); - assert(min_1 >= min_1); - assert(min_1 <= min_1); - - assert(min_1 <= one_1); - assert(min_1 <= neg_one_1); - assert(min_1 <= max_1); - assert(neg_one_1 <= max_1); - assert(neg_one_1 <= one_1); - assert(one_1 <= max_1); - - assert(max_1 >= one_1); - assert(max_1 >= neg_one_1); - assert(max_1 >= min_1); - assert(one_1 >= neg_one_1); - assert(one_1 >= min_1); - assert(neg_one_1 >= min_1); - - // Test neg try from + assert(zero.underlying() == u256::zero()); + assert(one.underlying() == 0x1u256); + assert(max.underlying() == u256::max()); +} + +#[test] +fn signed_i256_max() { + let max = I256::max(); + assert(max.underlying() == u256::max()); +} + +#[test] +fn signed_i256_min() { + let max = I256::min(); + assert(max.underlying() == u256::min()); +} + +#[test] +fn signed_i256_neg_try_from() { let indent = I256::indent(); let neg_try_from_zero = I256::neg_try_from(u256::min()); assert(neg_try_from_zero.is_some()); assert(neg_try_from_zero.unwrap() == I256::zero()); - let neg_try_from_one = I256::neg_try_from(u256_one); + let neg_try_from_one = I256::neg_try_from(0x1u256); assert(neg_try_from_one.is_some()); - assert(neg_try_from_one.unwrap().underlying() == I256::indent() - u256_one); + assert(neg_try_from_one.unwrap().underlying() == I256::indent() - 0x1u256); let neg_try_from_max = I256::neg_try_from(indent); assert(neg_try_from_max.is_some()); assert(neg_try_from_max.unwrap().underlying() == u256::min()); - let neg_try_from_overflow = I256::neg_try_from(indent + u256_one); + let neg_try_from_overflow = I256::neg_try_from(indent + 0x1u256); assert(neg_try_from_overflow.is_none()); +} + +#[test] +fn signed_i256_new() { + let new = I256::new(); + + assert(new.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); +} + +#[test] +fn signed_i256_zero() { + let zero = I256::zero(); + + assert(zero.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); +} + +#[test] +fn signed_i256_is_zero() { + let zero = I256::zero(); + assert(zero.is_zero()); + + let other_1 = I256::from_uint(0x1u256); + let other_2 = I256::max(); + assert(!other_1.is_zero()); + assert(!other_2.is_zero()); +} + +#[test] +fn signed_i256_underlying() { + let zero = I256::from_uint(0x0u256); + let one = I256::from_uint(0x1u256); + let max = I256::from_uint(u256::max()); + let indent = I256::zero(); + + assert(zero.underlying() == 0x0u256); + assert(one.underlying() == 0x1u256); + assert(max.underlying() == u256::max()); + assert(indent.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); +} + +#[test] +fn signed_i256_add() { + let pos1 = I256::try_from(0x1u256).unwrap(); + let pos2 = I256::try_from(0x2u256).unwrap(); + let neg1 = I256::neg_try_from(0x1u256).unwrap(); + let neg2 = I256::neg_try_from(0x2u256).unwrap(); + + // Both positive: + let res1 = pos1 + pos2; + assert(res1 == I256::try_from(0x3u256).unwrap()); + + let res2 = pos2 + pos1; + assert(res2 == I256::try_from(0x3u256).unwrap()); + + // First positive + let res3 = pos1 + neg1; + assert(res3 == I256::zero()); + + let res4 = pos2 + neg1; + assert(res4 == I256::try_from(0x1u256).unwrap()); + + let res5 = pos1 + neg2; + assert(res5 == I256::neg_try_from(0x1u256).unwrap()); + + // Second positive + let res6 = neg1 + pos1; + assert(res6 == I256::zero()); + + let res7 = neg2 + pos1; + assert(res7 == I256::neg_try_from(0x1u256).unwrap()); + + let res8 = neg1 + pos2; + assert(res8 == I256::try_from(0x1u256).unwrap()); + + // Both negative + let res9 = neg1 + neg2; + assert(res9 == I256::neg_try_from(0x3u256).unwrap()); + + let res10 = neg2 + neg1; + assert(res10 == I256::neg_try_from(0x3u256).unwrap()); + + // Edge Cases + let res11 = I256::min() + I256::max(); + assert(res11 == I256::neg_try_from(0x1u256).unwrap()); + + let res12 = I256::max() + I256::zero(); + assert(res12 == I256::max()); + + let res13 = I256::min() + I256::zero(); + assert(res13 == I256::min()); + + let res14 = I256::zero() + I256::zero(); + assert(res14 == I256::zero()); +} + +#[test(should_revert)] +fn revert_signed_i256_add() { + let one = I256::try_from(0x1u256).unwrap(); + let max = I256::max(); + + let _ = max + one; +} + +#[test(should_revert)] +fn revert_signed_i256_add_negative() { + let neg_one = I256::neg_try_from(0x1u256).unwrap(); + let min = I256::min(); + + let _ = min + neg_one; +} + +#[test(should_revert)] +fn revert_signed_i256_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let one = I256::try_from(0x1u256).unwrap(); + let max = I256::max(); + + let _ = max + one; +} + +#[test] +fn signed_i256_add_overflow() { + let _ = disable_panic_on_overflow(); + + let one = I256::try_from(0x1u256).unwrap(); + let max = I256::max(); + + assert(max + one == I256::min()); +} + +#[test] +fn signed_i256_subtract() { + let pos1 = I256::try_from(0x1u256).unwrap(); + let pos2 = I256::try_from(0x2u256).unwrap(); + let neg1 = I256::neg_try_from(0x1u256).unwrap(); + let neg2 = I256::neg_try_from(0x2u256).unwrap(); + + // Both positive: + let res1 = pos1 - pos2; + assert(res1 == I256::neg_try_from(0x1u256).unwrap()); + + let res2 = pos2 - pos1; + assert(res2 == I256::try_from(0x1u256).unwrap()); + + // First positive + let res3 = pos1 - neg1; + assert(res3 == I256::try_from(0x2u256).unwrap()); + + let res4 = pos2 - neg1; + assert(res4 == I256::try_from(0x3u256).unwrap()); + + // Second positive + let res5 = neg1 - pos1; + assert(res5 == I256::neg_try_from(0x2u256).unwrap()); + + let res6 = neg2 - pos1; + assert(res6 == I256::neg_try_from(0x3u256).unwrap()); + + // Both negative + let res7 = neg1 - neg2; + assert(res7 == I256::try_from(0x1u256).unwrap()); + + let res8 = neg2 - neg1; + assert(res8 == I256::neg_try_from(0x1u256).unwrap()); + + // Edge Cases + let res11 = I256::zero() - (I256::min() + I256::try_from(0x1u256).unwrap()); + assert(res11 == I256::max()); + + let res12 = I256::max() - I256::zero(); + assert(res12 == I256::max()); + + let res13 = I256::min() - I256::zero(); + assert(res13 == I256::min()); + + let res14 = I256::zero() - I256::zero(); + assert(res14 == I256::zero()); +} + +#[test(should_revert)] +fn revert_signed_i256_sub() { + let min = I256::min(); + let one = I256::try_from(0x1u256).unwrap(); + + let _ = min - one; +} + +#[test(should_revert)] +fn revert_signed_i256_sub_negative() { + let max = I256::max(); + let neg_one = I256::neg_try_from(0x1u256).unwrap(); + + let _ = max - neg_one; +} + +#[test(should_revert)] +fn revert_signed_i256_sub_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let min = I256::min(); + let one = I256::try_from(0x1u256).unwrap(); + + let _ = min - one; +} + +#[test] +fn signed_i256_sub_underflow() { + let _ = disable_panic_on_overflow(); + + let min = I256::min(); + let one = I256::try_from(0x1u256).unwrap(); + + let result = min - one; + assert(result == I256::max()); +} + +#[test] +fn signed_i256_multiply() { + let pos1 = I256::try_from(0x1u256).unwrap(); + let pos2 = I256::try_from(0x2u256).unwrap(); + let neg1 = I256::neg_try_from(0x1u256).unwrap(); + let neg2 = I256::neg_try_from(0x2u256).unwrap(); - // Test into I256 + // Both positive: + let res1 = pos1 * pos2; + assert(res1 == I256::try_from(0x2u256).unwrap()); + + let res2 = pos2 * pos1; + assert(res2 == I256::try_from(0x2u256).unwrap()); + + // First positive + let res3 = pos1 * neg1; + assert(res3 == I256::neg_try_from(0x1u256).unwrap()); + + let res4 = pos2 * neg1; + assert(res4 == I256::neg_try_from(0x2u256).unwrap()); + + let res5 = pos1 * neg2; + assert(res5 == I256::neg_try_from(0x2u256).unwrap()); + + // Second positive + let res6 = neg1 * pos1; + assert(res6 == I256::neg_try_from(0x1u256).unwrap()); + + let res7 = neg2 * pos1; + assert(res7 == I256::neg_try_from(0x2u256).unwrap()); + + let res8 = neg1 * pos2; + assert(res8 == I256::neg_try_from(0x2u256).unwrap()); + + // Both negative + let res9 = neg1 * neg2; + assert(res9 == I256::try_from(0x2u256).unwrap()); + + let res10 = neg2 * neg1; + assert(res10 == I256::try_from(0x2u256).unwrap()); + + // Edge Cases + let res12 = I256::max() * I256::zero(); + assert(res12 == I256::zero()); + + let res13 = I256::min() * I256::zero(); + assert(res13 == I256::zero()); + + let res14 = I256::zero() * I256::zero(); + assert(res14 == I256::zero()); +} + +#[test(should_revert)] +fn revert_signed_i256_mul() { + let max = I256::max(); + let two = I256::try_from(0x2u256).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i256_mul_negatice() { + let max = I256::max(); + let two = I256::neg_try_from(0x2u256).unwrap(); + + let _ = max * two; +} + +#[test(should_revert)] +fn revert_signed_i256_mul_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + + let max = I256::max(); + let two = I256::try_from(0x2u256).unwrap(); + + let _ = max * two; +} + +#[test] +fn signed_i256_mul() { + let _ = disable_panic_on_overflow(); + + let max = I256::max(); + let two = I256::try_from(0x2u256).unwrap(); + + let result = max * two; + assert(result == I256::neg_try_from(0x2u256).unwrap()); +} + +#[test] +fn signed_i256_divide() { + let pos1 = I256::try_from(0x1u256).unwrap(); + let pos2 = I256::try_from(0x2u256).unwrap(); + let neg1 = I256::neg_try_from(0x1u256).unwrap(); + let neg2 = I256::neg_try_from(0x2u256).unwrap(); + + // Both positive: + let res1 = pos1 / pos2; + assert(res1 == I256::zero()); + + let res2 = pos2 / pos1; + assert(res2 == I256::try_from(0x2u256).unwrap()); + + // First positive + let res3 = pos1 / neg1; + assert(res3 == I256::neg_try_from(0x1u256).unwrap()); + + let res4 = pos2 / neg1; + assert(res4 == I256::neg_try_from(0x2u256).unwrap()); + + let res5 = pos1 / neg2; + assert(res5 == I256::zero()); + + // Second positive + let res6 = neg1 / pos1; + assert(res6 == I256::neg_try_from(0x1u256).unwrap()); + + let res7 = neg2 / pos1; + assert(res7 == I256::neg_try_from(0x2u256).unwrap()); + + let res8 = neg1 / pos2; + assert(res8 == I256::zero()); + + // Both negative + let res9 = neg1 / neg2; + assert(res9 == I256::zero()); + + let res10 = neg2 / neg1; + assert(res10 == I256::try_from(0x2u256).unwrap()); + + // Edge Cases + let res12 = I256::zero() / I256::max(); + assert(res12 == I256::zero()); + + let res13 = I256::zero() / I256::min(); + assert(res13 == I256::zero()); +} + +#[test(should_revert)] +fn revert_signed_i256_divide() { + let zero = I256::zero(); + let one = I256::try_from(0x1u256).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i256_divide_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); + let zero = I256::zero(); + let one = I256::try_from(0x1u256).unwrap(); + + let res = one / zero; + assert(res == I256::zero()); +} + +#[test(should_revert)] +fn revert_signed_i256_divide_disable_overflow() { + let _ = disable_panic_on_overflow(); + let zero = I256::zero(); + let one = I256::try_from(0x1u256).unwrap(); + + let _ = one / zero; +} + +#[test] +fn signed_i256_wrapping_neg() { + let one = I256::try_from(0x1u256).unwrap(); + let neg_one = I256::neg_try_from(0x1u256).unwrap(); + let two = I256::try_from(0x2u256).unwrap(); + let neg_two = I256::neg_try_from(0x2u256).unwrap(); + let ten = I256::try_from(0x10u256).unwrap(); + let neg_ten = I256::neg_try_from(0x10u256).unwrap(); + let twenty_seven = I256::try_from(0x27u256).unwrap(); + let neg_twenty_seven = I256::neg_try_from(0x27u256).unwrap(); + let ninty_three = I256::try_from(0x93u256).unwrap(); + let neg_ninty_three = I256::neg_try_from(0x93u256).unwrap(); + let zero = I256::try_from(u256::zero()).unwrap(); + let max = I256::max(); + let min = I256::min(); + let neg_min_plus_one = I256::min() + I256::try_from(0x1u256).unwrap(); + + let res1 = one.wrapping_neg(); + let res2 = neg_one.wrapping_neg(); + assert(res1 == neg_one); + assert(res2 == one); + + let res3 = two.wrapping_neg(); + let res4 = neg_two.wrapping_neg(); + assert(res3 == neg_two); + assert(res4 == two); + + let res5 = ten.wrapping_neg(); + let res6 = neg_ten.wrapping_neg(); + assert(res5 == neg_ten); + assert(res6 == ten); + + let res7 = twenty_seven.wrapping_neg(); + let res8 = neg_twenty_seven.wrapping_neg(); + assert(res7 == neg_twenty_seven); + assert(res8 == twenty_seven); + + let res9 = ninty_three.wrapping_neg(); + let res10 = neg_ninty_three.wrapping_neg(); + assert(res9 == neg_ninty_three); + assert(res10 == ninty_three); + + let res11 = zero.wrapping_neg(); + let res12 = max.wrapping_neg(); + let res13 = min.wrapping_neg(); + + assert(res11 == zero); + assert(res12 == neg_min_plus_one); + assert(res13 == min); +} + +#[test] +fn signed_i256_try_from_u256() { let indent: u256 = I256::indent(); - let i256_max_try_from = I256::try_from(indent); + let i256_max_try_from = I256::try_from(indent - 0x1u256); assert(i256_max_try_from.is_some()); assert(i256_max_try_from.unwrap() == I256::max()); @@ -159,28 +590,39 @@ fn main() -> bool { assert(i256_min_try_from.is_some()); assert(i256_min_try_from.unwrap() == I256::zero()); - let i256_overflow_try_from = I256::try_from(indent + u256_one); - assert(i256_overflow_try_from.is_none()); + let i256_overflow_try_from = I256::try_from(indent); + assert(i256_overflow_try_from.is_none()); +} - let i256_max_try_into: Option = indent.try_into(); - assert(i256_max_try_into.is_some()); - assert(i256_max_try_into.unwrap() == I256::max()); +#[test] +fn signed_i256_try_into_u256() { + let zero = I256::zero(); + let negative = I256::neg_try_from(0x1u256).unwrap(); + let max = I256::max(); + let indent: u256 = I256::indent(); - let i256_min_try_into: Option = u256::min().try_into(); - assert(i256_min_try_into.is_some()); - assert(i256_min_try_into.unwrap() == I256::zero()); + let u256_max_try_into: Option = max.try_into(); + assert(u256_max_try_into.is_some()); + assert(u256_max_try_into.unwrap() == indent - 0x1u256); - let i256_overflow_try_into: Option = (indent + u256_one).try_into(); - assert(i256_overflow_try_into.is_none()); + let u256_min_try_into: Option = zero.try_into(); + assert(u256_min_try_into.is_some()); + assert(u256_min_try_into.unwrap() == u256::zero()); - // Test into u256 + let u256_overflow_try_into: Option = negative.try_into(); + assert(u256_overflow_try_into.is_none()); +} + +#[test] +fn signed_i256_u256_try_from() { let zero = I256::zero(); - let negative = I256::neg_try_from(u256_one).unwrap(); + let negative = I256::neg_try_from(0x1u256).unwrap(); let max = I256::max(); + let indent: u256 = I256::indent(); let u256_max_try_from: Option = u256::try_from(max); assert(u256_max_try_from.is_some()); - assert(u256_max_try_from.unwrap() == indent); + assert(u256_max_try_from.unwrap() == indent - 0x1u256); let u256_min_try_from: Option = u256::try_from(zero); assert(u256_min_try_from.is_some()); @@ -188,17 +630,20 @@ fn main() -> bool { let u256_overflow_try_from: Option = u256::try_from(negative); assert(u256_overflow_try_from.is_none()); +} - let u256_max_try_into: Option = zero.try_into(); - assert(u256_max_try_into.is_some()); - assert(u256_max_try_into.unwrap() == indent); +#[test] +fn signed_i256_u256_try_into() { + let indent: u256 = I256::indent(); - let u256_min_try_into: Option = zero.try_into(); - assert(u256_min_try_into.is_some()); - assert(u256_min_try_into.unwrap() == u256::zero()); + let i256_max_try_into: Option = (indent - 0x1u256).try_into(); + assert(i256_max_try_into.is_some()); + assert(i256_max_try_into.unwrap() == I256::max()); - let u256_overflow_try_into: Option = negative.try_into(); - assert(u256_overflow_try_into.is_none()); + let i256_min_try_into: Option = u256::min().try_into(); + assert(i256_min_try_into.is_some()); + assert(i256_min_try_into.unwrap() == I256::zero()); - true + let i256_overflow_try_into: Option = indent.try_into(); + assert(i256_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i256/tests/mod.rs b/tests/src/signed_integers/signed_i256/tests/mod.rs deleted file mode 100644 index 72099951..00000000 --- a/tests/src/signed_integers/signed_i256/tests/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi256", - abi = "src/signed_integers/signed_i256/out/release/i256_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i256_test_script() { - let path_to_bin = "src/signed_integers/signed_i256/out/release/i256_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi256::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} diff --git a/tests/src/signed_integers/signed_i256_wrapping_neg/.gitignore b/tests/src/signed_integers/signed_i256_wrapping_neg/.gitignore deleted file mode 100644 index 77d3844f..00000000 --- a/tests/src/signed_integers/signed_i256_wrapping_neg/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -out -target diff --git a/tests/src/signed_integers/signed_i256_wrapping_neg/Forc.toml b/tests/src/signed_integers/signed_i256_wrapping_neg/Forc.toml deleted file mode 100644 index 85795249..00000000 --- a/tests/src/signed_integers/signed_i256_wrapping_neg/Forc.toml +++ /dev/null @@ -1,8 +0,0 @@ -[project] -authors = ["Fuel Labs "] -entry = "main.sw" -license = "Apache-2.0" -name = "i256_wrapping_neg_test" - -[dependencies] -sway_libs = { path = "../../../../libs" } diff --git a/tests/src/signed_integers/signed_i256_wrapping_neg/mod.rs b/tests/src/signed_integers/signed_i256_wrapping_neg/mod.rs deleted file mode 100644 index dc39c4cc..00000000 --- a/tests/src/signed_integers/signed_i256_wrapping_neg/mod.rs +++ /dev/null @@ -1 +0,0 @@ -mod tests; diff --git a/tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw deleted file mode 100644 index 5260df80..00000000 --- a/tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw +++ /dev/null @@ -1,81 +0,0 @@ -script; - -use sway_libs::signed_integers::i256::I256; - -fn main() -> bool { - let parts_one = (0, 0, 0, 1); - let parts_two = (0, 0, 0, 2); - let parts_ten = (0, 0, 0, 10); - let parts_twenty_seven = (0, 0, 0, 27); - let parts_ninty_three = (0, 0, 0, 93); - let u_one = asm(r1: parts_one) { - r1: u256 - }; - let u_two = asm(r1: parts_two) { - r1: u256 - }; - let u_ten = asm(r1: parts_ten) { - r1: u256 - }; - let u_twenty_seven = asm(r1: parts_twenty_seven) { - r1: u256 - }; - let u_ninty_three = asm(r1: parts_ninty_three) { - r1: u256 - }; - - let one = I256::try_from(u_one).unwrap(); - let neg_one = I256::neg_try_from(u_one).unwrap(); - - let two = I256::try_from(u_two).unwrap(); - let neg_two = I256::neg_try_from(u_two).unwrap(); - - let ten = I256::try_from(u_ten).unwrap(); - let neg_ten = I256::neg_try_from(u_ten).unwrap(); - - let twenty_seven = I256::try_from(u_twenty_seven).unwrap(); - let neg_twenty_seven = I256::neg_try_from(u_twenty_seven).unwrap(); - - let ninty_three = I256::try_from(u_ninty_three).unwrap(); - let neg_ninty_three = I256::neg_try_from(u_ninty_three).unwrap(); - - let zero = I256::try_from(u256::zero()).unwrap(); - let max = I256::max(); - let min = I256::min(); - let neg_min_plus_one = I256::min() + I256::try_from(u_one).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i256_wrapping_neg/tests/mod.rs b/tests/src/signed_integers/signed_i256_wrapping_neg/tests/mod.rs deleted file mode 100644 index 6bdf83b7..00000000 --- a/tests/src/signed_integers/signed_i256_wrapping_neg/tests/mod.rs +++ /dev/null @@ -1,23 +0,0 @@ -use fuels::prelude::{abigen, launch_provider_and_get_wallet}; - -abigen!(Script( - name = "Testi256WrappingNeg", - abi = - "src/signed_integers/signed_i256_wrapping_neg/out/release/i256_wrapping_neg_test-abi.json" -),); - -mod success { - - use super::*; - - #[tokio::test] - async fn runs_i256_wrapping_neg_test_script() { - let path_to_bin = - "src/signed_integers/signed_i256_wrapping_neg/out/release/i256_wrapping_neg_test.bin"; - let wallet = launch_provider_and_get_wallet().await.unwrap(); - - let instance = Testi256WrappingNeg::new(wallet, path_to_bin); - - let _result = instance.main().call().await; - } -} From 04a0dd7f545af0f2b8610d1096dd9b3d9bcfc251 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Fri, 7 Mar 2025 16:19:37 -0300 Subject: [PATCH 07/13] Run formmater --- libs/src/signed_integers/i128.sw | 4 +-- libs/src/signed_integers/i16.sw | 2 +- libs/src/signed_integers/i256.sw | 2 +- libs/src/signed_integers/i32.sw | 2 +- libs/src/signed_integers/i64.sw | 2 +- libs/src/signed_integers/i8.sw | 4 +-- .../signed_integers/signed_i128/src/main.sw | 16 +++++----- .../signed_integers/signed_i16/src/main.sw | 12 +++---- .../signed_integers/signed_i256/src/main.sw | 31 +++++++++++++------ .../signed_integers/signed_i32/src/main.sw | 12 +++---- .../signed_integers/signed_i64/src/main.sw | 12 +++---- .../src/signed_integers/signed_i8/src/main.sw | 13 ++++---- 12 files changed, 61 insertions(+), 51 deletions(-) diff --git a/libs/src/signed_integers/i128.sw b/libs/src/signed_integers/i128.sw index 68065702..e4901bd1 100644 --- a/libs/src/signed_integers/i128.sw +++ b/libs/src/signed_integers/i128.sw @@ -301,7 +301,7 @@ impl core::ops::Divide for I128 { if panic_on_unsafe_math_enabled() { require(divisor != Self::new(), Error::ZeroDivisor); } - let mut res = Self::new(); + let mut res = Self::new(); if (self.underlying > Self::indent() || self.underlying == Self::indent()) && divisor.underlying > Self::indent() @@ -440,7 +440,7 @@ impl TryFrom for U128 { impl TryInto for U128 { fn try_into(self) -> Option { if self < I128::indent() { - Some(I128 { + Some(I128 { underlying: self + I128::indent(), }) } else { diff --git a/libs/src/signed_integers/i16.sw b/libs/src/signed_integers/i16.sw index 6efe0f04..28ac1e44 100644 --- a/libs/src/signed_integers/i16.sw +++ b/libs/src/signed_integers/i16.sw @@ -429,7 +429,7 @@ impl TryFrom for u16 { impl TryInto for u16 { fn try_into(self) -> Option { if self < I16::indent() { - Some(I16 { + Some(I16 { underlying: self + I16::indent(), }) } else { diff --git a/libs/src/signed_integers/i256.sw b/libs/src/signed_integers/i256.sw index c75bda07..de9e5582 100644 --- a/libs/src/signed_integers/i256.sw +++ b/libs/src/signed_integers/i256.sw @@ -420,7 +420,7 @@ impl TryFrom for u256 { impl TryInto for u256 { fn try_into(self) -> Option { if self < I256::indent() { - Some(I256 { + Some(I256 { underlying: self + I256::indent(), }) } else { diff --git a/libs/src/signed_integers/i32.sw b/libs/src/signed_integers/i32.sw index fff6a91a..f2942db3 100644 --- a/libs/src/signed_integers/i32.sw +++ b/libs/src/signed_integers/i32.sw @@ -429,7 +429,7 @@ impl TryFrom for u32 { impl TryInto for u32 { fn try_into(self) -> Option { if self < I32::indent() { - Some(I32 { + Some(I32 { underlying: self + I32::indent(), }) } else { diff --git a/libs/src/signed_integers/i64.sw b/libs/src/signed_integers/i64.sw index 48866401..27e569dd 100644 --- a/libs/src/signed_integers/i64.sw +++ b/libs/src/signed_integers/i64.sw @@ -430,7 +430,7 @@ impl TryFrom for u64 { impl TryInto for u64 { fn try_into(self) -> Option { if self < I64::indent() { - Some(I64 { + Some(I64 { underlying: self + I64::indent(), }) } else { diff --git a/libs/src/signed_integers/i8.sw b/libs/src/signed_integers/i8.sw index 32a29d8b..832a3b67 100644 --- a/libs/src/signed_integers/i8.sw +++ b/libs/src/signed_integers/i8.sw @@ -291,7 +291,7 @@ impl core::ops::Divide for I8 { if panic_on_unsafe_math_enabled() { require(divisor != Self::new(), Error::ZeroDivisor); } - + let mut res = Self::new(); if self.underlying >= Self::indent() && divisor.underlying > Self::indent() @@ -429,7 +429,7 @@ impl TryFrom for u8 { impl TryInto for u8 { fn try_into(self) -> Option { if self < I8::indent() { - Some(I8 { + Some(I8 { underlying: self + I8::indent(), }) } else { diff --git a/tests/src/signed_integers/signed_i128/src/main.sw b/tests/src/signed_integers/signed_i128/src/main.sw index 8bf45ebc..2f81cc1f 100644 --- a/tests/src/signed_integers/signed_i128/src/main.sw +++ b/tests/src/signed_integers/signed_i128/src/main.sw @@ -25,7 +25,7 @@ fn signed_i128_eq() { let i128_11 = I128::try_from(U128::from((1, 0))).unwrap(); let i128_12 = I128::try_from(U128::from((1, 0))).unwrap(); let i128_13 = I128::neg_try_from(U128::from((1, 0))).unwrap(); - let i128_14= I128::neg_try_from(U128::from((1, 0))).unwrap(); + let i128_14 = I128::neg_try_from(U128::from((1, 0))).unwrap(); assert(i128_1 == i128_2); assert(i128_3 == i128_4); @@ -78,7 +78,7 @@ fn signed_i128_ord() { let i128_11 = I128::try_from(U128::from((1, 0))).unwrap(); let i128_12 = I128::try_from(U128::from((1, 0))).unwrap(); let i128_13 = I128::neg_try_from(U128::from((1, 0))).unwrap(); - let i128_14= I128::neg_try_from(U128::from((1, 0))).unwrap(); + let i128_14 = I128::neg_try_from(U128::from((1, 0))).unwrap(); assert(!(i128_1 > i128_2)); assert(!(i128_3 > i128_4)); @@ -317,7 +317,7 @@ fn signed_i128_add() { fn revert_signed_i128_add() { let one = I128::try_from(U128::from((0, 1))).unwrap(); let max = I128::max(); - + let _ = max + one; } @@ -325,7 +325,7 @@ fn revert_signed_i128_add() { fn revert_signed_i128_add_negative() { let neg_one = I128::neg_try_from(U128::from((0, 1))).unwrap(); let min = I128::min(); - + let _ = min + neg_one; } @@ -335,17 +335,17 @@ fn revert_signed_i128_add_unsafe_math() { let one = I128::try_from(U128::from((0, 1))).unwrap(); let max = I128::max(); - + let _ = max + one; } #[test] fn signed_i128_add_overflow() { let _ = disable_panic_on_overflow(); - + let one = I128::try_from(U128::from((0, 1))).unwrap(); let max = I128::max(); - + assert(max + one == I128::min()); } @@ -671,7 +671,7 @@ fn signed_i128_try_from_u128() { assert(i128_min_try_from.unwrap() == I128::zero()); let i128_overflow_try_from = I128::try_from(indent); - assert(i128_overflow_try_from.is_none()); + assert(i128_overflow_try_from.is_none()); } #[test] diff --git a/tests/src/signed_integers/signed_i16/src/main.sw b/tests/src/signed_integers/signed_i16/src/main.sw index 38690955..ca15a503 100644 --- a/tests/src/signed_integers/signed_i16/src/main.sw +++ b/tests/src/signed_integers/signed_i16/src/main.sw @@ -244,7 +244,7 @@ fn signed_i16_add() { fn revert_signed_i16_add() { let one = I16::try_from(1u16).unwrap(); let max = I16::max(); - + let _ = max + one; } @@ -252,7 +252,7 @@ fn revert_signed_i16_add() { fn revert_signed_i16_add_negative() { let neg_one = I16::neg_try_from(1u16).unwrap(); let min = I16::min(); - + let _ = min + neg_one; } @@ -262,17 +262,17 @@ fn revert_signed_i16_add_unsafe_math() { let one = I16::try_from(1u16).unwrap(); let max = I16::max(); - + let _ = max + one; } #[test] fn signed_i16_add_overflow() { let _ = disable_panic_on_overflow(); - + let one = I16::try_from(1u16).unwrap(); let max = I16::max(); - + assert(max + one == I16::min()); } @@ -591,7 +591,7 @@ fn signed_i16_try_from_u16() { assert(i16_min_try_from.unwrap() == I16::zero()); let i16_overflow_try_from = I16::try_from(indent); - assert(i16_overflow_try_from.is_none()); + assert(i16_overflow_try_from.is_none()); } #[test] diff --git a/tests/src/signed_integers/signed_i256/src/main.sw b/tests/src/signed_integers/signed_i256/src/main.sw index 7c602739..26e2085f 100644 --- a/tests/src/signed_integers/signed_i256/src/main.sw +++ b/tests/src/signed_integers/signed_i256/src/main.sw @@ -6,7 +6,9 @@ use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; #[test] fn signed_i256_indent() { - assert(I256::indent() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); + assert( + I256::indent() == 0x8000000000000000000000000000000000000000000000000000000000000000u256, + ); } #[test] @@ -151,14 +153,20 @@ fn signed_i256_neg_try_from() { fn signed_i256_new() { let new = I256::new(); - assert(new.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); + assert( + new + .underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256, + ); } #[test] fn signed_i256_zero() { let zero = I256::zero(); - assert(zero.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); + assert( + zero + .underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256, + ); } #[test] @@ -182,7 +190,10 @@ fn signed_i256_underlying() { assert(zero.underlying() == 0x0u256); assert(one.underlying() == 0x1u256); assert(max.underlying() == u256::max()); - assert(indent.underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256); + assert( + indent + .underlying() == 0x8000000000000000000000000000000000000000000000000000000000000000u256, + ); } #[test] @@ -244,7 +255,7 @@ fn signed_i256_add() { fn revert_signed_i256_add() { let one = I256::try_from(0x1u256).unwrap(); let max = I256::max(); - + let _ = max + one; } @@ -252,7 +263,7 @@ fn revert_signed_i256_add() { fn revert_signed_i256_add_negative() { let neg_one = I256::neg_try_from(0x1u256).unwrap(); let min = I256::min(); - + let _ = min + neg_one; } @@ -262,17 +273,17 @@ fn revert_signed_i256_add_unsafe_math() { let one = I256::try_from(0x1u256).unwrap(); let max = I256::max(); - + let _ = max + one; } #[test] fn signed_i256_add_overflow() { let _ = disable_panic_on_overflow(); - + let one = I256::try_from(0x1u256).unwrap(); let max = I256::max(); - + assert(max + one == I256::min()); } @@ -591,7 +602,7 @@ fn signed_i256_try_from_u256() { assert(i256_min_try_from.unwrap() == I256::zero()); let i256_overflow_try_from = I256::try_from(indent); - assert(i256_overflow_try_from.is_none()); + assert(i256_overflow_try_from.is_none()); } #[test] diff --git a/tests/src/signed_integers/signed_i32/src/main.sw b/tests/src/signed_integers/signed_i32/src/main.sw index 5a9f3a29..3d30ac74 100644 --- a/tests/src/signed_integers/signed_i32/src/main.sw +++ b/tests/src/signed_integers/signed_i32/src/main.sw @@ -244,7 +244,7 @@ fn signed_i32_add() { fn revert_signed_i32_add() { let one = I32::try_from(1u32).unwrap(); let max = I32::max(); - + let _ = max + one; } @@ -252,7 +252,7 @@ fn revert_signed_i32_add() { fn revert_signed_i32_add_negative() { let neg_one = I32::neg_try_from(1u32).unwrap(); let min = I32::min(); - + let _ = min + neg_one; } @@ -262,17 +262,17 @@ fn revert_signed_i32_add_unsafe_math() { let one = I32::try_from(1u32).unwrap(); let max = I32::max(); - + let _ = max + one; } #[test] fn signed_i32_add_overflow() { let _ = disable_panic_on_overflow(); - + let one = I32::try_from(1u32).unwrap(); let max = I32::max(); - + assert(max + one == I32::min()); } @@ -592,7 +592,7 @@ fn signed_i32_try_from_u32() { assert(i32_min_try_from.unwrap() == I32::zero()); let i32_overflow_try_from = I32::try_from(indent); - assert(i32_overflow_try_from.is_none()); + assert(i32_overflow_try_from.is_none()); } #[test] diff --git a/tests/src/signed_integers/signed_i64/src/main.sw b/tests/src/signed_integers/signed_i64/src/main.sw index 273cc039..33d5a3f7 100644 --- a/tests/src/signed_integers/signed_i64/src/main.sw +++ b/tests/src/signed_integers/signed_i64/src/main.sw @@ -244,7 +244,7 @@ fn signed_i64_add() { fn revert_signed_i64_add() { let one = I64::try_from(1u64).unwrap(); let max = I64::max(); - + let _ = max + one; } @@ -252,7 +252,7 @@ fn revert_signed_i64_add() { fn revert_signed_i64_add_negative() { let neg_one = I64::neg_try_from(1u64).unwrap(); let min = I64::min(); - + let _ = min + neg_one; } @@ -262,17 +262,17 @@ fn revert_signed_i64_add_unsafe_math() { let one = I64::try_from(1u64).unwrap(); let max = I64::max(); - + let _ = max + one; } #[test] fn signed_i64_add_overflow() { let _ = disable_panic_on_overflow(); - + let one = I64::try_from(1u64).unwrap(); let max = I64::max(); - + assert(max + one == I64::min()); } @@ -591,7 +591,7 @@ fn signed_i64_try_from_u64() { assert(i64_min_try_from.unwrap() == I64::zero()); let i64_overflow_try_from = I64::try_from(indent); - assert(i64_overflow_try_from.is_none()); + assert(i64_overflow_try_from.is_none()); } #[test] diff --git a/tests/src/signed_integers/signed_i8/src/main.sw b/tests/src/signed_integers/signed_i8/src/main.sw index 2f88a934..3504093c 100644 --- a/tests/src/signed_integers/signed_i8/src/main.sw +++ b/tests/src/signed_integers/signed_i8/src/main.sw @@ -244,7 +244,7 @@ fn signed_i8_add() { fn revert_signed_i8_add() { let one = I8::try_from(1u8).unwrap(); let max = I8::max(); - + let _ = max + one; } @@ -252,7 +252,7 @@ fn revert_signed_i8_add() { fn revert_signed_i8_add_negative() { let neg_one = I8::neg_try_from(1u8).unwrap(); let min = I8::min(); - + let _ = min + neg_one; } @@ -262,17 +262,17 @@ fn revert_signed_i8_add_unsafe_math() { let one = I8::try_from(1u8).unwrap(); let max = I8::max(); - + let _ = max + one; } #[test] fn signed_i8_add_overflow() { let _ = disable_panic_on_overflow(); - + let one = I8::try_from(1u8).unwrap(); let max = I8::max(); - + assert(max + one == I8::min()); } @@ -591,7 +591,7 @@ fn signed_i8_try_from_u8() { assert(i8_min_try_from.unwrap() == I8::zero()); let i8_overflow_try_from = I8::try_from(indent); - assert(i8_overflow_try_from.is_none()); + assert(i8_overflow_try_from.is_none()); } #[test] @@ -646,5 +646,4 @@ fn signed_i8_u8_try_into() { let i8_overflow_try_into: Option = indent.try_into(); assert(i8_overflow_try_into.is_none()); - } From 48fb6f602d726004b31be2aea770992a7693e574 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Mon, 10 Mar 2025 09:45:50 -0300 Subject: [PATCH 08/13] Resolve merge conflicts --- .../signed_integers/signed_i128/src/main.sw | 102 +++++++---- .../signed_i128_wrapping_neg/src/main.sw | 61 ------- .../signed_integers/signed_i16/src/main.sw | 130 ++++++++----- .../signed_i16_wrapping_neg/src/main.sw | 60 ------ .../signed_integers/signed_i256/src/main.sw | 130 ++++++++----- .../signed_i256_wrapping_neg/src/main.sw | 81 --------- .../signed_integers/signed_i32/src/main.sw | 172 +++++++++++++----- .../signed_i32_wrapping_neg/src/main.sw | 60 ------ .../signed_integers/signed_i64/src/main.sw | 130 ++++++++----- .../signed_i64_wrapping_neg/src/main.sw | 60 ------ .../src/signed_integers/signed_i8/src/main.sw | 130 ++++++++----- .../signed_i8_wrapping_neg/src/main.sw | 60 ------ 12 files changed, 522 insertions(+), 654 deletions(-) delete mode 100644 tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw delete mode 100644 tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw diff --git a/tests/src/signed_integers/signed_i128/src/main.sw b/tests/src/signed_integers/signed_i128/src/main.sw index 990042d8..2a00d247 100644 --- a/tests/src/signed_integers/signed_i128/src/main.sw +++ b/tests/src/signed_integers/signed_i128/src/main.sw @@ -137,6 +137,40 @@ fn signed_i128_ord() { assert(i128_11 > i128_13); } +#[test] +fn signed_i128_total_ord() { + let zero = I128::zero(); + let one = I128::try_from(U128::from((0,1))).unwrap(); + let max_1 = I128::MAX; + let min_1 = I128::MIN; + let neg_one_1 = I128::neg_try_from(U128::from((0,1))).unwrap(); + + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); + + assert(max_1.min(one) == one); + assert(max_1.max(one) == max_1); + assert(one.min(max_1) == one); + assert(one.max(max_1) == max_1); + + assert(min_1.min(one) == min_1); + assert(min_1.max(one) == one); + assert(one.min(min_1) == min_1); + assert(one.max(min_1) == one); + + assert(max_1.min(min_1) == min_1); + assert(max_1.max(min_1) == max_1); + assert(min_1.min(max_1) == min_1); + assert(min_1.max(max_1) == max_1); + + assert(neg_one_1.min(one) == neg_one_1); + assert(neg_one_1.max(one) == one); + assert(one.min(neg_one_1) == neg_one_1); + assert(one.max(neg_one_1) == one); +} + #[test] fn signed_i128_bits() { assert(I128::bits() == 128); @@ -156,13 +190,13 @@ fn signed_i128_from_uint() { } #[test] -fn signed_i128_MAX() { +fn signed_i128_max_constant() { let max = I128::MAX; assert(max.underlying() == U128::max()); } #[test] -fn signed_i128_MIN() { +fn signed_i128_min_constant() { let max = I128::MIN; assert(max.underlying() == U128::min()); } @@ -207,7 +241,7 @@ fn signed_i128_is_zero() { assert(zero.is_zero()); let other_1 = I128::from_uint(U128::from((0, 1))); - let other_2 = I128::max(); + let other_2 = I128::MAX; assert(!other_1.is_zero()); assert(!other_2.is_zero()); } @@ -304,7 +338,7 @@ fn signed_i128_add() { assert(res11 == I128::neg_try_from(U128::from((0, 1))).unwrap()); let res12 = I128::MAX + I128::zero(); - assert(res12 == I128::max()); + assert(res12 == I128::MAX); let res13 = I128::MIN + I128::zero(); assert(res13 == I128::MIN); @@ -316,7 +350,7 @@ fn signed_i128_add() { #[test(should_revert)] fn revert_signed_i128_add() { let one = I128::try_from(U128::from((0, 1))).unwrap(); - let max = I128::max(); + let max = I128::MAX; let _ = max + one; } @@ -324,7 +358,7 @@ fn revert_signed_i128_add() { #[test(should_revert)] fn revert_signed_i128_add_negative() { let neg_one = I128::neg_try_from(U128::from((0, 1))).unwrap(); - let min = I128::min(); + let min = I128::MIN; let _ = min + neg_one; } @@ -334,7 +368,7 @@ fn revert_signed_i128_add_unsafe_math() { let _ = disable_panic_on_unsafe_math(); let one = I128::try_from(U128::from((0, 1))).unwrap(); - let max = I128::max(); + let max = I128::MAX; let _ = max + one; } @@ -344,9 +378,9 @@ fn signed_i128_add_overflow() { let _ = disable_panic_on_overflow(); let one = I128::try_from(U128::from((0, 1))).unwrap(); - let max = I128::max(); + let max = I128::MAX; - assert(max + one == I128::min()); + assert(max + one == I128::MIN); } #[test] @@ -385,14 +419,14 @@ fn signed_i128_subtract() { assert(res8 == I128::neg_try_from(U128::from((0, 1))).unwrap()); // Edge Cases - let res11 = I128::zero() - (I128::min() + I128::try_from(U128::from((0, 1))).unwrap()); - assert(res11 == I128::max()); + let res11 = I128::zero() - (I128::MIN + I128::try_from(U128::from((0, 1))).unwrap()); + assert(res11 == I128::MAX); - let res12 = I128::max() - I128::zero(); - assert(res12 == I128::max()); + let res12 = I128::MAX - I128::zero(); + assert(res12 == I128::MAX); - let res13 = I128::min() - I128::zero(); - assert(res13 == I128::min()); + let res13 = I128::MIN - I128::zero(); + assert(res13 == I128::MIN); let res14 = I128::zero() - I128::zero(); assert(res14 == I128::zero()); @@ -400,7 +434,7 @@ fn signed_i128_subtract() { #[test(should_revert)] fn revert_signed_i128_sub() { - let min = I128::min(); + let min = I128::MIN; let one = I128::try_from(U128::from((0, 1))).unwrap(); let _ = min - one; @@ -408,7 +442,7 @@ fn revert_signed_i128_sub() { #[test(should_revert)] fn revert_signed_i128_sub_negative() { - let max = I128::max(); + let max = I128::MAX; let neg_one = I128::neg_try_from(U128::from((0, 1))).unwrap(); let _ = max - neg_one; @@ -418,7 +452,7 @@ fn revert_signed_i128_sub_negative() { fn revert_signed_i128_sub_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let min = I128::min(); + let min = I128::MIN; let one = I128::try_from(U128::from((0, 1))).unwrap(); let _ = min - one; @@ -428,11 +462,11 @@ fn revert_signed_i128_sub_unsafe_math() { fn signed_i128_sub_underflow() { let _ = disable_panic_on_overflow(); - let min = I128::min(); + let min = I128::MIN; let one = I128::try_from(U128::from((0, 1))).unwrap(); let result = min - one; - assert(result == I128::max()); + assert(result == I128::MAX); } #[test] @@ -477,10 +511,10 @@ fn signed_i128_multiply() { assert(res10 == I128::try_from(U128::from((0, 2))).unwrap()); // Edge Cases - let res12 = I128::max() * I128::zero(); + let res12 = I128::MAX * I128::zero(); assert(res12 == I128::zero()); - let res13 = I128::min() * I128::zero(); + let res13 = I128::MIN * I128::zero(); assert(res13 == I128::zero()); let res14 = I128::zero() * I128::zero(); @@ -489,7 +523,7 @@ fn signed_i128_multiply() { #[test(should_revert)] fn revert_signed_i128_mul() { - let max = I128::max(); + let max = I128::MAX; let two = I128::try_from(U128::from((0, 2))).unwrap(); let _ = max * two; @@ -497,7 +531,7 @@ fn revert_signed_i128_mul() { #[test(should_revert)] fn revert_signed_i128_mul_negatice() { - let max = I128::max(); + let max = I128::MAX; let two = I128::neg_try_from(U128::from((0, 2))).unwrap(); let _ = max * two; @@ -507,7 +541,7 @@ fn revert_signed_i128_mul_negatice() { fn revert_signed_i128_mul_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let max = I128::max(); + let max = I128::MAX; let two = I128::try_from(U128::from((0, 2))).unwrap(); let _ = max * two; @@ -517,7 +551,7 @@ fn revert_signed_i128_mul_unsafe_math() { fn signed_i128_mul() { let _ = disable_panic_on_overflow(); - let max = I128::max(); + let max = I128::MAX; let two = I128::try_from(U128::from((0, 2))).unwrap(); let result = max * two; @@ -566,10 +600,10 @@ fn signed_i128_divide() { assert(res10 == I128::try_from(U128::from((0, 2))).unwrap()); // Edge Cases - let res12 = I128::zero() / I128::max(); + let res12 = I128::zero() / I128::MAX; assert(res12 == I128::zero()); - let res13 = I128::zero() / I128::min(); + let res13 = I128::zero() / I128::MIN; assert(res13 == I128::zero()); } @@ -615,9 +649,9 @@ fn signed_i128_wrapping_neg() { let upper_u128 = I128::try_from(U128::from((1, 0))).unwrap(); let neg_upper_u128 = I128::neg_try_from(U128::from((1, 0))).unwrap(); let zero = I128::try_from(U128::from((0, 0))).unwrap(); - let max = I128::max(); - let min = I128::min(); - let neg_min_plus_one = I128::min() + I128::try_from(U128::from((0, 1))).unwrap(); + let max = I128::MAX; + let min = I128::MIN; + let neg_min_plus_one = I128::MIN + I128::try_from(U128::from((0, 1))).unwrap(); let res1 = one.wrapping_neg(); let res2 = neg_one.wrapping_neg(); @@ -678,7 +712,7 @@ fn signed_i128_try_from_u128() { fn signed_i128_try_into_u128() { let zero = I128::zero(); let negative = I128::neg_try_from(U128::from((0, 1))).unwrap(); - let max = I128::max(); + let max = I128::MAX; let indent: U128 = I128::indent(); let U128_max_try_into: Option = max.try_into(); @@ -697,7 +731,7 @@ fn signed_i128_try_into_u128() { fn signed_i128_u128_try_from() { let zero = I128::zero(); let negative = I128::neg_try_from(U128::from((0, 1))).unwrap(); - let max = I128::max(); + let max = I128::MAX; let indent: U128 = I128::indent(); let U128_max_try_from: Option = U128::try_from(max); @@ -718,7 +752,7 @@ fn signed_i128_u128_try_into() { let i128_max_try_into: Option = (indent - U128::from((0, 1))).try_into(); assert(i128_max_try_into.is_some()); - assert(i128_max_try_into.unwrap() == I128::max()); + assert(i128_max_try_into.unwrap() == I128::MAX); let i128_min_try_into: Option = U128::min().try_into(); assert(i128_min_try_into.is_some()); diff --git a/tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw deleted file mode 100644 index 29ccfcc0..00000000 --- a/tests/src/signed_integers/signed_i128_wrapping_neg/src/main.sw +++ /dev/null @@ -1,61 +0,0 @@ -script; - -use sway_libs::signed_integers::i128::I128; -use std::u128::U128; - -fn main() -> bool { - let one = I128::try_from(U128::from(1u64)).unwrap(); - let neg_one = I128::neg_try_from(U128::from(1u64)).unwrap(); - - let two = I128::try_from(U128::from(2u64)).unwrap(); - let neg_two = I128::neg_try_from(U128::from(2u64)).unwrap(); - - let ten = I128::try_from(U128::from(10u64)).unwrap(); - let neg_ten = I128::neg_try_from(U128::from(10u64)).unwrap(); - - let twenty_seven = I128::try_from(U128::from(27u64)).unwrap(); - let neg_twenty_seven = I128::neg_try_from(U128::from(27u64)).unwrap(); - - let ninty_three = I128::try_from(U128::from(93u64)).unwrap(); - let neg_ninty_three = I128::neg_try_from(U128::from(93u64)).unwrap(); - - let zero = I128::try_from(U128::zero()).unwrap(); - let max = I128::MAX; - let min = I128::MIN; - let neg_min_plus_one = I128::MIN + I128::try_from(U128::from((0, 1))).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i16/src/main.sw b/tests/src/signed_integers/signed_i16/src/main.sw index d1ffde46..1774bb13 100644 --- a/tests/src/signed_integers/signed_i16/src/main.sw +++ b/tests/src/signed_integers/signed_i16/src/main.sw @@ -15,10 +15,10 @@ fn signed_i16_eq() { let i16_2 = I16::zero(); let i16_3 = I16::try_from(1u16).unwrap(); let i16_4 = I16::try_from(1u16).unwrap(); - let i16_5 = I16::max(); - let i16_6 = I16::max(); - let i16_7 = I16::min(); - let i16_8 = I16::min(); + let i16_5 = I16::MAX; + let i16_6 = I16::MAX; + let i16_7 = I16::MIN; + let i16_8 = I16::MIN; let i16_9 = I16::neg_try_from(1u16).unwrap(); let i16_10 = I16::neg_try_from(1u16).unwrap(); @@ -49,10 +49,10 @@ fn signed_i16_ord() { let i16_2 = I16::zero(); let i16_3 = I16::try_from(1u16).unwrap(); let i16_4 = I16::try_from(1u16).unwrap(); - let i16_5 = I16::max(); - let i16_6 = I16::max(); - let i16_7 = I16::min(); - let i16_8 = I16::min(); + let i16_5 = I16::MAX; + let i16_6 = I16::MAX; + let i16_7 = I16::MIN; + let i16_8 = I16::MIN; let i16_9 = I16::neg_try_from(1u16).unwrap(); let i16_10 = I16::neg_try_from(1u16).unwrap(); @@ -99,6 +99,40 @@ fn signed_i16_ord() { assert(i16_9 > i16_7); } +#[test] +fn signed_i16_total_ord() { + let zero = I16::zero(); + let one = I16::try_from(1u16).unwrap(); + let max_1 = I16::MAX; + let min_1 = I16::MIN; + let neg_one_1 = I16::neg_try_from(1u16).unwrap(); + + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); + + assert(max_1.min(one) == one); + assert(max_1.max(one) == max_1); + assert(one.min(max_1) == one); + assert(one.max(max_1) == max_1); + + assert(min_1.min(one) == min_1); + assert(min_1.max(one) == one); + assert(one.min(min_1) == min_1); + assert(one.max(min_1) == one); + + assert(max_1.min(min_1) == min_1); + assert(max_1.max(min_1) == max_1); + assert(min_1.min(max_1) == min_1); + assert(min_1.max(max_1) == max_1); + + assert(neg_one_1.min(one) == neg_one_1); + assert(neg_one_1.max(one) == one); + assert(one.min(neg_one_1) == neg_one_1); + assert(one.max(neg_one_1) == one); +} + #[test] fn signed_i16_bits() { assert(I16::bits() == 16); @@ -116,14 +150,14 @@ fn signed_i16_from_uint() { } #[test] -fn signed_i16_max() { - let max = I16::max(); +fn signed_i16_max_constant() { + let max = I16::MAX; assert(max.underlying() == u16::max()); } #[test] -fn signed_i16_min() { - let max = I16::min(); +fn signed_i16_min_constant() { + let max = I16::MIN; assert(max.underlying() == u16::min()); } @@ -167,7 +201,7 @@ fn signed_i16_is_zero() { assert(zero.is_zero()); let other_1 = I16::from_uint(1); - let other_2 = I16::max(); + let other_2 = I16::MAX; assert(!other_1.is_zero()); assert(!other_2.is_zero()); } @@ -227,14 +261,14 @@ fn signed_i16_add() { assert(res10 == I16::neg_try_from(3).unwrap()); // Edge Cases - let res11 = I16::min() + I16::max(); + let res11 = I16::MIN + I16::MAX; assert(res11 == I16::neg_try_from(1).unwrap()); - let res12 = I16::max() + I16::zero(); - assert(res12 == I16::max()); + let res12 = I16::MAX + I16::zero(); + assert(res12 == I16::MAX); - let res13 = I16::min() + I16::zero(); - assert(res13 == I16::min()); + let res13 = I16::MIN + I16::zero(); + assert(res13 == I16::MIN); let res14 = I16::zero() + I16::zero(); assert(res14 == I16::zero()); @@ -243,7 +277,7 @@ fn signed_i16_add() { #[test(should_revert)] fn revert_signed_i16_add() { let one = I16::try_from(1u16).unwrap(); - let max = I16::max(); + let max = I16::MAX; let _ = max + one; } @@ -251,7 +285,7 @@ fn revert_signed_i16_add() { #[test(should_revert)] fn revert_signed_i16_add_negative() { let neg_one = I16::neg_try_from(1u16).unwrap(); - let min = I16::min(); + let min = I16::MIN; let _ = min + neg_one; } @@ -261,7 +295,7 @@ fn revert_signed_i16_add_unsafe_math() { let _ = disable_panic_on_unsafe_math(); let one = I16::try_from(1u16).unwrap(); - let max = I16::max(); + let max = I16::MAX; let _ = max + one; } @@ -271,9 +305,9 @@ fn signed_i16_add_overflow() { let _ = disable_panic_on_overflow(); let one = I16::try_from(1u16).unwrap(); - let max = I16::max(); + let max = I16::MAX; - assert(max + one == I16::min()); + assert(max + one == I16::MIN); } #[test] @@ -312,14 +346,14 @@ fn signed_i16_subtract() { assert(res8 == I16::neg_try_from(1).unwrap()); // Edge Cases - let res11 = I16::zero() - (I16::min() + I16::try_from(1).unwrap()); - assert(res11 == I16::max()); + let res11 = I16::zero() - (I16::MIN + I16::try_from(1).unwrap()); + assert(res11 == I16::MAX); - let res12 = I16::max() - I16::zero(); - assert(res12 == I16::max()); + let res12 = I16::MAX - I16::zero(); + assert(res12 == I16::MAX); - let res13 = I16::min() - I16::zero(); - assert(res13 == I16::min()); + let res13 = I16::MIN - I16::zero(); + assert(res13 == I16::MIN); let res14 = I16::zero() - I16::zero(); assert(res14 == I16::zero()); @@ -327,7 +361,7 @@ fn signed_i16_subtract() { #[test(should_revert)] fn revert_signed_i16_sub() { - let min = I16::min(); + let min = I16::MIN; let one = I16::try_from(1u16).unwrap(); let _ = min - one; @@ -335,7 +369,7 @@ fn revert_signed_i16_sub() { #[test(should_revert)] fn revert_signed_i16_sub_negative() { - let max = I16::max(); + let max = I16::MAX; let neg_one = I16::neg_try_from(1u16).unwrap(); let _ = max - neg_one; @@ -345,7 +379,7 @@ fn revert_signed_i16_sub_negative() { fn revert_signed_i16_sub_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let min = I16::min(); + let min = I16::MIN; let one = I16::try_from(1u16).unwrap(); let _ = min - one; @@ -355,11 +389,11 @@ fn revert_signed_i16_sub_unsafe_math() { fn signed_i16_sub_underflow() { let _ = disable_panic_on_overflow(); - let min = I16::min(); + let min = I16::MIN; let one = I16::try_from(1u16).unwrap(); let result = min - one; - assert(result == I16::max()); + assert(result == I16::MAX); } #[test] @@ -404,10 +438,10 @@ fn signed_i16_multiply() { assert(res10 == I16::try_from(2).unwrap()); // Edge Cases - let res12 = I16::max() * I16::zero(); + let res12 = I16::MAX * I16::zero(); assert(res12 == I16::zero()); - let res13 = I16::min() * I16::zero(); + let res13 = I16::MIN * I16::zero(); assert(res13 == I16::zero()); let res14 = I16::zero() * I16::zero(); @@ -416,7 +450,7 @@ fn signed_i16_multiply() { #[test(should_revert)] fn revert_signed_i16_mul() { - let max = I16::max(); + let max = I16::MAX; let two = I16::try_from(2u16).unwrap(); let _ = max * two; @@ -424,7 +458,7 @@ fn revert_signed_i16_mul() { #[test(should_revert)] fn revert_signed_i16_mul_negatice() { - let max = I16::max(); + let max = I16::MAX; let two = I16::neg_try_from(2u16).unwrap(); let _ = max * two; @@ -434,7 +468,7 @@ fn revert_signed_i16_mul_negatice() { fn revert_signed_i16_mul_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let max = I16::max(); + let max = I16::MAX; let two = I16::try_from(2u16).unwrap(); let _ = max * two; @@ -444,7 +478,7 @@ fn revert_signed_i16_mul_unsafe_math() { fn signed_i16_mul() { let _ = disable_panic_on_overflow(); - let max = I16::max(); + let max = I16::MAX; let two = I16::try_from(2u16).unwrap(); let result = max * two; @@ -493,10 +527,10 @@ fn signed_i16_divide() { assert(res10 == I16::try_from(2).unwrap()); // Edge Cases - let res12 = I16::zero() / I16::max(); + let res12 = I16::zero() / I16::MAX; assert(res12 == I16::zero()); - let res13 = I16::zero() / I16::min(); + let res13 = I16::zero() / I16::MIN; assert(res13 == I16::zero()); } @@ -540,9 +574,9 @@ fn signed_i16_wrapping_neg() { let ninty_three = I16::try_from(93u16).unwrap(); let neg_ninty_three = I16::neg_try_from(93u16).unwrap(); let zero = I16::try_from(0u16).unwrap(); - let max = I16::max(); - let min = I16::min(); - let neg_min_plus_one = I16::min() + I16::try_from(1u16).unwrap(); + let max = I16::MAX; + let min = I16::MIN; + let neg_min_plus_one = I16::MIN + I16::try_from(1u16).unwrap(); let res1 = one.wrapping_neg(); let res2 = neg_one.wrapping_neg(); @@ -598,7 +632,7 @@ fn signed_i16_try_from_u16() { fn signed_i16_try_into_u16() { let zero = I16::zero(); let negative = I16::neg_try_from(1).unwrap(); - let max = I16::max(); + let max = I16::MAX; let indent: u16 = I16::indent(); let u16_max_try_into: Option = max.try_into(); @@ -617,7 +651,7 @@ fn signed_i16_try_into_u16() { fn signed_i16_u16_try_from() { let zero = I16::zero(); let negative = I16::neg_try_from(1).unwrap(); - let max = I16::max(); + let max = I16::MAX; let indent: u16 = I16::indent(); let u16_max_try_from: Option = u16::try_from(max); @@ -638,7 +672,7 @@ fn signed_i16_u16_try_into() { let i16_max_try_into: Option = (indent - 1).try_into(); assert(i16_max_try_into.is_some()); - assert(i16_max_try_into.unwrap() == I16::max()); + assert(i16_max_try_into.unwrap() == I16::MAX); let i16_min_try_into: Option = u16::min().try_into(); assert(i16_min_try_into.is_some()); diff --git a/tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw deleted file mode 100644 index a9909323..00000000 --- a/tests/src/signed_integers/signed_i16_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i16::I16; - -fn main() -> bool { - let one = I16::try_from(1u16).unwrap(); - let neg_one = I16::neg_try_from(1u16).unwrap(); - - let two = I16::try_from(2u16).unwrap(); - let neg_two = I16::neg_try_from(2u16).unwrap(); - - let ten = I16::try_from(10u16).unwrap(); - let neg_ten = I16::neg_try_from(10u16).unwrap(); - - let twenty_seven = I16::try_from(27u16).unwrap(); - let neg_twenty_seven = I16::neg_try_from(27u16).unwrap(); - - let ninty_three = I16::try_from(93u16).unwrap(); - let neg_ninty_three = I16::neg_try_from(93u16).unwrap(); - - let zero = I16::try_from(0u16).unwrap(); - let max = I16::MAX; - let min = I16::MIN; - let neg_min_plus_one = I16::MIN + I16::try_from(1u16).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i256/src/main.sw b/tests/src/signed_integers/signed_i256/src/main.sw index a3e1eba1..61d58662 100644 --- a/tests/src/signed_integers/signed_i256/src/main.sw +++ b/tests/src/signed_integers/signed_i256/src/main.sw @@ -17,10 +17,10 @@ fn signed_i256_eq() { let i256_2 = I256::zero(); let i256_3 = I256::try_from(0x1u256).unwrap(); let i256_4 = I256::try_from(0x1u256).unwrap(); - let i256_5 = I256::max(); - let i256_6 = I256::max(); - let i256_7 = I256::min(); - let i256_8 = I256::min(); + let i256_5 = I256::MAX; + let i256_6 = I256::MAX; + let i256_7 = I256::MIN; + let i256_8 = I256::MIN; let i256_9 = I256::neg_try_from(0x1u256).unwrap(); let i256_10 = I256::neg_try_from(0x1u256).unwrap(); @@ -51,10 +51,10 @@ fn signed_i256_ord() { let i256_2 = I256::zero(); let i256_3 = I256::try_from(0x1u256).unwrap(); let i256_4 = I256::try_from(0x1u256).unwrap(); - let i256_5 = I256::max(); - let i256_6 = I256::max(); - let i256_7 = I256::min(); - let i256_8 = I256::min(); + let i256_5 = I256::MAX; + let i256_6 = I256::MAX; + let i256_7 = I256::MIN; + let i256_8 = I256::MIN; let i256_9 = I256::neg_try_from(0x1u256).unwrap(); let i256_10 = I256::neg_try_from(0x1u256).unwrap(); @@ -101,6 +101,40 @@ fn signed_i256_ord() { assert(i256_9 > i256_7); } +#[test] +fn signed_i256_total_ord() { + let zero = I256::zero(); + let one = I256::try_from(0x01u256).unwrap(); + let max_1 = I256::MAX; + let min_1 = I256::MIN; + let neg_one_1 = I256::neg_try_from(0x01u256).unwrap(); + + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); + + assert(max_1.min(one) == one); + assert(max_1.max(one) == max_1); + assert(one.min(max_1) == one); + assert(one.max(max_1) == max_1); + + assert(min_1.min(one) == min_1); + assert(min_1.max(one) == one); + assert(one.min(min_1) == min_1); + assert(one.max(min_1) == one); + + assert(max_1.min(min_1) == min_1); + assert(max_1.max(min_1) == max_1); + assert(min_1.min(max_1) == min_1); + assert(min_1.max(max_1) == max_1); + + assert(neg_one_1.min(one) == neg_one_1); + assert(neg_one_1.max(one) == one); + assert(one.min(neg_one_1) == neg_one_1); + assert(one.max(neg_one_1) == one); +} + #[test] fn signed_i256_bits() { assert(I256::bits() == 256); @@ -118,14 +152,14 @@ fn signed_i256_from_uint() { } #[test] -fn signed_i256_max() { - let max = I256::max(); +fn signed_i256_max_constant() { + let max = I256::MAX; assert(max.underlying() == u256::max()); } #[test] -fn signed_i256_min() { - let max = I256::min(); +fn signed_i256_min_constant() { + let max = I256::MIN; assert(max.underlying() == u256::min()); } @@ -175,7 +209,7 @@ fn signed_i256_is_zero() { assert(zero.is_zero()); let other_1 = I256::from_uint(0x1u256); - let other_2 = I256::max(); + let other_2 = I256::MAX; assert(!other_1.is_zero()); assert(!other_2.is_zero()); } @@ -238,14 +272,14 @@ fn signed_i256_add() { assert(res10 == I256::neg_try_from(0x3u256).unwrap()); // Edge Cases - let res11 = I256::min() + I256::max(); + let res11 = I256::MIN + I256::MAX; assert(res11 == I256::neg_try_from(0x1u256).unwrap()); - let res12 = I256::max() + I256::zero(); - assert(res12 == I256::max()); + let res12 = I256::MAX + I256::zero(); + assert(res12 == I256::MAX); - let res13 = I256::min() + I256::zero(); - assert(res13 == I256::min()); + let res13 = I256::MIN + I256::zero(); + assert(res13 == I256::MIN); let res14 = I256::zero() + I256::zero(); assert(res14 == I256::zero()); @@ -254,7 +288,7 @@ fn signed_i256_add() { #[test(should_revert)] fn revert_signed_i256_add() { let one = I256::try_from(0x1u256).unwrap(); - let max = I256::max(); + let max = I256::MAX; let _ = max + one; } @@ -262,7 +296,7 @@ fn revert_signed_i256_add() { #[test(should_revert)] fn revert_signed_i256_add_negative() { let neg_one = I256::neg_try_from(0x1u256).unwrap(); - let min = I256::min(); + let min = I256::MIN; let _ = min + neg_one; } @@ -272,7 +306,7 @@ fn revert_signed_i256_add_unsafe_math() { let _ = disable_panic_on_unsafe_math(); let one = I256::try_from(0x1u256).unwrap(); - let max = I256::max(); + let max = I256::MAX; let _ = max + one; } @@ -282,9 +316,9 @@ fn signed_i256_add_overflow() { let _ = disable_panic_on_overflow(); let one = I256::try_from(0x1u256).unwrap(); - let max = I256::max(); + let max = I256::MAX; - assert(max + one == I256::min()); + assert(max + one == I256::MIN); } #[test] @@ -323,14 +357,14 @@ fn signed_i256_subtract() { assert(res8 == I256::neg_try_from(0x1u256).unwrap()); // Edge Cases - let res11 = I256::zero() - (I256::min() + I256::try_from(0x1u256).unwrap()); - assert(res11 == I256::max()); + let res11 = I256::zero() - (I256::MIN + I256::try_from(0x1u256).unwrap()); + assert(res11 == I256::MAX); - let res12 = I256::max() - I256::zero(); - assert(res12 == I256::max()); + let res12 = I256::MAX - I256::zero(); + assert(res12 == I256::MAX); - let res13 = I256::min() - I256::zero(); - assert(res13 == I256::min()); + let res13 = I256::MIN - I256::zero(); + assert(res13 == I256::MIN); let res14 = I256::zero() - I256::zero(); assert(res14 == I256::zero()); @@ -338,7 +372,7 @@ fn signed_i256_subtract() { #[test(should_revert)] fn revert_signed_i256_sub() { - let min = I256::min(); + let min = I256::MIN; let one = I256::try_from(0x1u256).unwrap(); let _ = min - one; @@ -346,7 +380,7 @@ fn revert_signed_i256_sub() { #[test(should_revert)] fn revert_signed_i256_sub_negative() { - let max = I256::max(); + let max = I256::MAX; let neg_one = I256::neg_try_from(0x1u256).unwrap(); let _ = max - neg_one; @@ -356,7 +390,7 @@ fn revert_signed_i256_sub_negative() { fn revert_signed_i256_sub_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let min = I256::min(); + let min = I256::MIN; let one = I256::try_from(0x1u256).unwrap(); let _ = min - one; @@ -366,11 +400,11 @@ fn revert_signed_i256_sub_unsafe_math() { fn signed_i256_sub_underflow() { let _ = disable_panic_on_overflow(); - let min = I256::min(); + let min = I256::MIN; let one = I256::try_from(0x1u256).unwrap(); let result = min - one; - assert(result == I256::max()); + assert(result == I256::MAX); } #[test] @@ -415,10 +449,10 @@ fn signed_i256_multiply() { assert(res10 == I256::try_from(0x2u256).unwrap()); // Edge Cases - let res12 = I256::max() * I256::zero(); + let res12 = I256::MAX * I256::zero(); assert(res12 == I256::zero()); - let res13 = I256::min() * I256::zero(); + let res13 = I256::MIN * I256::zero(); assert(res13 == I256::zero()); let res14 = I256::zero() * I256::zero(); @@ -427,7 +461,7 @@ fn signed_i256_multiply() { #[test(should_revert)] fn revert_signed_i256_mul() { - let max = I256::max(); + let max = I256::MAX; let two = I256::try_from(0x2u256).unwrap(); let _ = max * two; @@ -435,7 +469,7 @@ fn revert_signed_i256_mul() { #[test(should_revert)] fn revert_signed_i256_mul_negatice() { - let max = I256::max(); + let max = I256::MAX; let two = I256::neg_try_from(0x2u256).unwrap(); let _ = max * two; @@ -445,7 +479,7 @@ fn revert_signed_i256_mul_negatice() { fn revert_signed_i256_mul_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let max = I256::max(); + let max = I256::MAX; let two = I256::try_from(0x2u256).unwrap(); let _ = max * two; @@ -455,7 +489,7 @@ fn revert_signed_i256_mul_unsafe_math() { fn signed_i256_mul() { let _ = disable_panic_on_overflow(); - let max = I256::max(); + let max = I256::MAX; let two = I256::try_from(0x2u256).unwrap(); let result = max * two; @@ -504,10 +538,10 @@ fn signed_i256_divide() { assert(res10 == I256::try_from(0x2u256).unwrap()); // Edge Cases - let res12 = I256::zero() / I256::max(); + let res12 = I256::zero() / I256::MAX; assert(res12 == I256::zero()); - let res13 = I256::zero() / I256::min(); + let res13 = I256::zero() / I256::MIN; assert(res13 == I256::zero()); } @@ -551,9 +585,9 @@ fn signed_i256_wrapping_neg() { let ninty_three = I256::try_from(0x93u256).unwrap(); let neg_ninty_three = I256::neg_try_from(0x93u256).unwrap(); let zero = I256::try_from(u256::zero()).unwrap(); - let max = I256::max(); - let min = I256::min(); - let neg_min_plus_one = I256::min() + I256::try_from(0x1u256).unwrap(); + let max = I256::MAX; + let min = I256::MIN; + let neg_min_plus_one = I256::MIN + I256::try_from(0x1u256).unwrap(); let res1 = one.wrapping_neg(); let res2 = neg_one.wrapping_neg(); @@ -609,7 +643,7 @@ fn signed_i256_try_from_u256() { fn signed_i256_try_into_u256() { let zero = I256::zero(); let negative = I256::neg_try_from(0x1u256).unwrap(); - let max = I256::max(); + let max = I256::MAX; let indent: u256 = I256::indent(); let u256_max_try_into: Option = max.try_into(); @@ -628,7 +662,7 @@ fn signed_i256_try_into_u256() { fn signed_i256_u256_try_from() { let zero = I256::zero(); let negative = I256::neg_try_from(0x1u256).unwrap(); - let max = I256::max(); + let max = I256::MAX; let indent: u256 = I256::indent(); let u256_max_try_from: Option = u256::try_from(max); @@ -649,7 +683,7 @@ fn signed_i256_u256_try_into() { let i256_max_try_into: Option = (indent - 0x1u256).try_into(); assert(i256_max_try_into.is_some()); - assert(i256_max_try_into.unwrap() == I256::max()); + assert(i256_max_try_into.unwrap() == I256::MAX); let i256_min_try_into: Option = u256::min().try_into(); assert(i256_min_try_into.is_some()); diff --git a/tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw deleted file mode 100644 index aae03882..00000000 --- a/tests/src/signed_integers/signed_i256_wrapping_neg/src/main.sw +++ /dev/null @@ -1,81 +0,0 @@ -script; - -use sway_libs::signed_integers::i256::I256; - -fn main() -> bool { - let parts_one = (0, 0, 0, 1); - let parts_two = (0, 0, 0, 2); - let parts_ten = (0, 0, 0, 10); - let parts_twenty_seven = (0, 0, 0, 27); - let parts_ninty_three = (0, 0, 0, 93); - let u_one = asm(r1: parts_one) { - r1: u256 - }; - let u_two = asm(r1: parts_two) { - r1: u256 - }; - let u_ten = asm(r1: parts_ten) { - r1: u256 - }; - let u_twenty_seven = asm(r1: parts_twenty_seven) { - r1: u256 - }; - let u_ninty_three = asm(r1: parts_ninty_three) { - r1: u256 - }; - - let one = I256::try_from(u_one).unwrap(); - let neg_one = I256::neg_try_from(u_one).unwrap(); - - let two = I256::try_from(u_two).unwrap(); - let neg_two = I256::neg_try_from(u_two).unwrap(); - - let ten = I256::try_from(u_ten).unwrap(); - let neg_ten = I256::neg_try_from(u_ten).unwrap(); - - let twenty_seven = I256::try_from(u_twenty_seven).unwrap(); - let neg_twenty_seven = I256::neg_try_from(u_twenty_seven).unwrap(); - - let ninty_three = I256::try_from(u_ninty_three).unwrap(); - let neg_ninty_three = I256::neg_try_from(u_ninty_three).unwrap(); - - let zero = I256::try_from(u256::zero()).unwrap(); - let max = I256::MAX; - let min = I256::MIN; - let neg_min_plus_one = I256::MIN + I256::try_from(u_one).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i32/src/main.sw b/tests/src/signed_integers/signed_i32/src/main.sw index 7397ac40..27b8da57 100644 --- a/tests/src/signed_integers/signed_i32/src/main.sw +++ b/tests/src/signed_integers/signed_i32/src/main.sw @@ -15,10 +15,10 @@ fn signed_i32_eq() { let i32_2 = I32::zero(); let i32_3 = I32::try_from(1u32).unwrap(); let i32_4 = I32::try_from(1u32).unwrap(); - let i32_5 = I32::max(); - let i32_6 = I32::max(); - let i32_7 = I32::min(); - let i32_8 = I32::min(); + let i32_5 = I32::MAX; + let i32_6 = I32::MAX; + let i32_7 = I32::MIN; + let i32_8 = I32::MIN; let i32_9 = I32::neg_try_from(1u32).unwrap(); let i32_10 = I32::neg_try_from(1u32).unwrap(); @@ -49,10 +49,10 @@ fn signed_i32_ord() { let i32_2 = I32::zero(); let i32_3 = I32::try_from(1u32).unwrap(); let i32_4 = I32::try_from(1u32).unwrap(); - let i32_5 = I32::max(); - let i32_6 = I32::max(); - let i32_7 = I32::min(); - let i32_8 = I32::min(); + let i32_5 = I32::MAX; + let i32_6 = I32::MAX; + let i32_7 = I32::MIN; + let i32_8 = I32::MIN; let i32_9 = I32::neg_try_from(1u32).unwrap(); let i32_10 = I32::neg_try_from(1u32).unwrap(); @@ -99,6 +99,40 @@ fn signed_i32_ord() { assert(i32_9 > i32_7); } +#[test] +fn signed_i32_total_ord() { + let zero = I32::zero(); + let one = I32::try_from(1u32).unwrap(); + let max_1 = I32::MAX; + let min_1 = I32::MIN; + let neg_one_1 = I32::neg_try_from(1u32).unwrap(); + + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); + + assert(max_1.min(one) == one); + assert(max_1.max(one) == max_1); + assert(one.min(max_1) == one); + assert(one.max(max_1) == max_1); + + assert(min_1.min(one) == min_1); + assert(min_1.max(one) == one); + assert(one.min(min_1) == min_1); + assert(one.max(min_1) == one); + + assert(max_1.min(min_1) == min_1); + assert(max_1.max(min_1) == max_1); + assert(min_1.min(max_1) == min_1); + assert(min_1.max(max_1) == max_1); + + assert(neg_one_1.min(one) == neg_one_1); + assert(neg_one_1.max(one) == one); + assert(one.min(neg_one_1) == neg_one_1); + assert(one.max(neg_one_1) == one); +} + #[test] fn signed_i32_bits() { assert(I32::bits() == 32); @@ -116,14 +150,14 @@ fn signed_i32_from_uint() { } #[test] -fn signed_i32_max() { - let max = I32::max(); +fn signed_i32_max_constant() { + let max = I32::MAX; assert(max.underlying() == u32::max()); } #[test] -fn signed_i32_min() { - let max = I32::min(); +fn signed_i32_min_constant() { + let max = I32::MIN; assert(max.underlying() == u32::min()); } @@ -167,7 +201,7 @@ fn signed_i32_is_zero() { assert(zero.is_zero()); let other_1 = I32::from_uint(1); - let other_2 = I32::max(); + let other_2 = I32::MAX; assert(!other_1.is_zero()); assert(!other_2.is_zero()); } @@ -227,14 +261,14 @@ fn signed_i32_add() { assert(res10 == I32::neg_try_from(3).unwrap()); // Edge Cases - let res11 = I32::min() + I32::max(); + let res11 = I32::MIN + I32::MAX; assert(res11 == I32::neg_try_from(1).unwrap()); - let res12 = I32::max() + I32::zero(); - assert(res12 == I32::max()); + let res12 = I32::MAX + I32::zero(); + assert(res12 == I32::MAX); - let res13 = I32::min() + I32::zero(); - assert(res13 == I32::min()); + let res13 = I32::MIN + I32::zero(); + assert(res13 == I32::MIN); let res14 = I32::zero() + I32::zero(); assert(res14 == I32::zero()); @@ -243,7 +277,7 @@ fn signed_i32_add() { #[test(should_revert)] fn revert_signed_i32_add() { let one = I32::try_from(1u32).unwrap(); - let max = I32::max(); + let max = I32::MAX; let _ = max + one; } @@ -251,7 +285,7 @@ fn revert_signed_i32_add() { #[test(should_revert)] fn revert_signed_i32_add_negative() { let neg_one = I32::neg_try_from(1u32).unwrap(); - let min = I32::min(); + let min = I32::MIN; let _ = min + neg_one; } @@ -261,7 +295,7 @@ fn revert_signed_i32_add_unsafe_math() { let _ = disable_panic_on_unsafe_math(); let one = I32::try_from(1u32).unwrap(); - let max = I32::max(); + let max = I32::MAX; let _ = max + one; } @@ -271,9 +305,9 @@ fn signed_i32_add_overflow() { let _ = disable_panic_on_overflow(); let one = I32::try_from(1u32).unwrap(); - let max = I32::max(); + let max = I32::MAX; - assert(max + one == I32::min()); + assert(max + one == I32::MIN); } #[test] @@ -312,14 +346,14 @@ fn signed_i32_subtract() { assert(res8 == I32::neg_try_from(1).unwrap()); // Edge Cases - let res11 = I32::zero() - (I32::min() + I32::try_from(1).unwrap()); - assert(res11 == I32::max()); + let res11 = I32::zero() - (I32::MIN + I32::try_from(1).unwrap()); + assert(res11 == I32::MAX); - let res12 = I32::max() - I32::zero(); - assert(res12 == I32::max()); + let res12 = I32::MAX - I32::zero(); + assert(res12 == I32::MAX); - let res13 = I32::min() - I32::zero(); - assert(res13 == I32::min()); + let res13 = I32::MIN - I32::zero(); + assert(res13 == I32::MIN); let res14 = I32::zero() - I32::zero(); assert(res14 == I32::zero()); @@ -327,7 +361,7 @@ fn signed_i32_subtract() { #[test(should_revert)] fn revert_signed_i32_sub() { - let min = I32::min(); + let min = I32::MIN; let one = I32::try_from(1u32).unwrap(); let _ = min - one; @@ -335,7 +369,7 @@ fn revert_signed_i32_sub() { #[test(should_revert)] fn revert_signed_i32_sub_negative() { - let max = I32::max(); + let max = I32::MAX; let neg_one = I32::neg_try_from(1u32).unwrap(); let _ = max - neg_one; @@ -345,7 +379,7 @@ fn revert_signed_i32_sub_negative() { fn revert_signed_i32_sub_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let min = I32::min(); + let min = I32::MIN; let one = I32::try_from(1u32).unwrap(); let _ = min - one; @@ -355,12 +389,12 @@ fn revert_signed_i32_sub_unsafe_math() { fn signed_i32_sub_underflow() { let _ = disable_panic_on_overflow(); - let min = I32::min(); + let min = I32::MIN; let one = I32::try_from(1u32).unwrap(); let result = min - one; log(result); - assert(result == I32::max()); + assert(result == I32::MAX); } #[test] @@ -405,10 +439,10 @@ fn signed_i32_multiply() { assert(res10 == I32::try_from(2).unwrap()); // Edge Cases - let res12 = I32::max() * I32::zero(); + let res12 = I32::MAX * I32::zero(); assert(res12 == I32::zero()); - let res13 = I32::min() * I32::zero(); + let res13 = I32::MIN * I32::zero(); assert(res13 == I32::zero()); let res14 = I32::zero() * I32::zero(); @@ -417,7 +451,7 @@ fn signed_i32_multiply() { #[test(should_revert)] fn revert_signed_i32_mul() { - let max = I32::max(); + let max = I32::MAX; let two = I32::try_from(2u32).unwrap(); let _ = max * two; @@ -425,7 +459,7 @@ fn revert_signed_i32_mul() { #[test(should_revert)] fn revert_signed_i32_mul_negatice() { - let max = I32::max(); + let max = I32::MAX; let two = I32::neg_try_from(2u32).unwrap(); let _ = max * two; @@ -435,7 +469,7 @@ fn revert_signed_i32_mul_negatice() { fn revert_signed_i32_mul_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let max = I32::max(); + let max = I32::MAX; let two = I32::try_from(2u32).unwrap(); let _ = max * two; @@ -445,7 +479,7 @@ fn revert_signed_i32_mul_unsafe_math() { fn signed_i32_mul() { let _ = disable_panic_on_overflow(); - let max = I32::max(); + let max = I32::MAX; let two = I32::try_from(2u32).unwrap(); let result = max * two; @@ -494,10 +528,10 @@ fn signed_i32_divide() { assert(res10 == I32::try_from(2).unwrap()); // Edge Cases - let res12 = I32::zero() / I32::max(); + let res12 = I32::zero() / I32::MAX; assert(res12 == I32::zero()); - let res13 = I32::zero() / I32::min(); + let res13 = I32::zero() / I32::MIN; assert(res13 == I32::zero()); } @@ -541,9 +575,9 @@ fn signed_i32_wrapping_neg() { let ninty_three = I32::try_from(93u32).unwrap(); let neg_ninty_three = I32::neg_try_from(93u32).unwrap(); let zero = I32::try_from(0u32).unwrap(); - let max = I32::max(); - let min = I32::min(); - let neg_min_plus_one = I32::min() + I32::try_from(1u32).unwrap(); + let max = I32::MAX; + let min = I32::MIN; + let neg_min_plus_one = I32::MIN + I32::try_from(1u32).unwrap(); let res1 = one.wrapping_neg(); let res2 = neg_one.wrapping_neg(); @@ -599,6 +633,52 @@ fn signed_i32_try_from_u32() { fn signed_i32_try_into_u32() { let zero = I32::zero(); let negative = I32::neg_try_from(1).unwrap(); - let max = I32::max(); + let max = I32::MAX; + let indent: u32 = I32::indent(); + + let u32_max_try_into: Option = max.try_into(); + assert(u32_max_try_into.is_some()); + assert(u32_max_try_into.unwrap() == indent - 1); + + let u32_min_try_into: Option = zero.try_into(); + assert(u32_min_try_into.is_some()); + assert(u32_min_try_into.unwrap() == u32::zero()); + + let u32_overflow_try_into: Option = negative.try_into(); + assert(u32_overflow_try_into.is_none()); +} + +#[test] +fn signed_i32_u32_try_from() { + let zero = I32::zero(); + let negative = I32::neg_try_from(1).unwrap(); + let max = I32::MAX; + let indent: u32 = I32::indent(); + + let u32_max_try_from: Option = u32::try_from(max); + assert(u32_max_try_from.is_some()); + assert(u32_max_try_from.unwrap() == indent - 1); + + let u32_min_try_from: Option = u32::try_from(zero); + assert(u32_min_try_from.is_some()); + assert(u32_min_try_from.unwrap() == u32::zero()); + + let u32_overflow_try_from: Option = u32::try_from(negative); + assert(u32_overflow_try_from.is_none()); +} + +#[test] +fn signed_i32_u32_try_into() { let indent: u32 = I32::indent(); + + let i32_max_try_into: Option = (indent - 1).try_into(); + assert(i32_max_try_into.is_some()); + assert(i32_max_try_into.unwrap() == I32::MAX); + + let i32_min_try_into: Option = u32::min().try_into(); + assert(i32_min_try_into.is_some()); + assert(i32_min_try_into.unwrap() == I32::zero()); + + let i32_overflow_try_into: Option = indent.try_into(); + assert(i32_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw deleted file mode 100644 index 064ac301..00000000 --- a/tests/src/signed_integers/signed_i32_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i32::I32; - -fn main() -> bool { - let one = I32::try_from(1u32).unwrap(); - let neg_one = I32::neg_try_from(1u32).unwrap(); - - let two = I32::try_from(2u32).unwrap(); - let neg_two = I32::neg_try_from(2u32).unwrap(); - - let ten = I32::try_from(10u32).unwrap(); - let neg_ten = I32::neg_try_from(10u32).unwrap(); - - let twenty_seven = I32::try_from(27u32).unwrap(); - let neg_twenty_seven = I32::neg_try_from(27u32).unwrap(); - - let ninty_three = I32::try_from(93u32).unwrap(); - let neg_ninty_three = I32::neg_try_from(93u32).unwrap(); - - let zero = I32::try_from(0u32).unwrap(); - let max = I32::MAX; - let min = I32::MIN; - let neg_min_plus_one = I32::MIN + I32::try_from(1u32).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i64/src/main.sw b/tests/src/signed_integers/signed_i64/src/main.sw index 695fbb70..f5f36c31 100644 --- a/tests/src/signed_integers/signed_i64/src/main.sw +++ b/tests/src/signed_integers/signed_i64/src/main.sw @@ -15,10 +15,10 @@ fn signed_i64_eq() { let i64_2 = I64::zero(); let i64_3 = I64::try_from(1u64).unwrap(); let i64_4 = I64::try_from(1u64).unwrap(); - let i64_5 = I64::max(); - let i64_6 = I64::max(); - let i64_7 = I64::min(); - let i64_8 = I64::min(); + let i64_5 = I64::MAX; + let i64_6 = I64::MAX; + let i64_7 = I64::MIN; + let i64_8 = I64::MIN; let i64_9 = I64::neg_try_from(1u64).unwrap(); let i64_10 = I64::neg_try_from(1u64).unwrap(); @@ -49,10 +49,10 @@ fn signed_i64_ord() { let i64_2 = I64::zero(); let i64_3 = I64::try_from(1u64).unwrap(); let i64_4 = I64::try_from(1u64).unwrap(); - let i64_5 = I64::max(); - let i64_6 = I64::max(); - let i64_7 = I64::min(); - let i64_8 = I64::min(); + let i64_5 = I64::MAX; + let i64_6 = I64::MAX; + let i64_7 = I64::MIN; + let i64_8 = I64::MIN; let i64_9 = I64::neg_try_from(1u64).unwrap(); let i64_10 = I64::neg_try_from(1u64).unwrap(); @@ -99,6 +99,40 @@ fn signed_i64_ord() { assert(i64_9 > i64_7); } +#[test] +fn signed_i64_total_ord() { + let zero = I64::zero(); + let one = I64::try_from(1u64).unwrap(); + let max_1 = I64::MAX; + let min_1 = I64::MIN; + let neg_one_1 = I64::neg_try_from(1u64).unwrap(); + + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); + + assert(max_1.min(one) == one); + assert(max_1.max(one) == max_1); + assert(one.min(max_1) == one); + assert(one.max(max_1) == max_1); + + assert(min_1.min(one) == min_1); + assert(min_1.max(one) == one); + assert(one.min(min_1) == min_1); + assert(one.max(min_1) == one); + + assert(max_1.min(min_1) == min_1); + assert(max_1.max(min_1) == max_1); + assert(min_1.min(max_1) == min_1); + assert(min_1.max(max_1) == max_1); + + assert(neg_one_1.min(one) == neg_one_1); + assert(neg_one_1.max(one) == one); + assert(one.min(neg_one_1) == neg_one_1); + assert(one.max(neg_one_1) == one); +} + #[test] fn signed_i64_bits() { assert(I64::bits() == 64); @@ -116,14 +150,14 @@ fn signed_i64_from_uint() { } #[test] -fn signed_i64_max() { - let max = I64::max(); +fn signed_i64_max_constant() { + let max = I64::MAX; assert(max.underlying() == u64::max()); } #[test] -fn signed_i64_min() { - let max = I64::min(); +fn signed_i64_min_constant() { + let max = I64::MIN; assert(max.underlying() == u64::min()); } @@ -167,7 +201,7 @@ fn signed_i64_is_zero() { assert(zero.is_zero()); let other_1 = I64::from_uint(1); - let other_2 = I64::max(); + let other_2 = I64::MAX; assert(!other_1.is_zero()); assert(!other_2.is_zero()); } @@ -227,14 +261,14 @@ fn signed_i64_add() { assert(res10 == I64::neg_try_from(3).unwrap()); // Edge Cases - let res11 = I64::min() + I64::max(); + let res11 = I64::MIN + I64::MAX; assert(res11 == I64::neg_try_from(1).unwrap()); - let res12 = I64::max() + I64::zero(); - assert(res12 == I64::max()); + let res12 = I64::MAX + I64::zero(); + assert(res12 == I64::MAX); - let res13 = I64::min() + I64::zero(); - assert(res13 == I64::min()); + let res13 = I64::MIN + I64::zero(); + assert(res13 == I64::MIN); let res14 = I64::zero() + I64::zero(); assert(res14 == I64::zero()); @@ -243,7 +277,7 @@ fn signed_i64_add() { #[test(should_revert)] fn revert_signed_i64_add() { let one = I64::try_from(1u64).unwrap(); - let max = I64::max(); + let max = I64::MAX; let _ = max + one; } @@ -251,7 +285,7 @@ fn revert_signed_i64_add() { #[test(should_revert)] fn revert_signed_i64_add_negative() { let neg_one = I64::neg_try_from(1u64).unwrap(); - let min = I64::min(); + let min = I64::MIN; let _ = min + neg_one; } @@ -261,7 +295,7 @@ fn revert_signed_i64_add_unsafe_math() { let _ = disable_panic_on_unsafe_math(); let one = I64::try_from(1u64).unwrap(); - let max = I64::max(); + let max = I64::MAX; let _ = max + one; } @@ -271,9 +305,9 @@ fn signed_i64_add_overflow() { let _ = disable_panic_on_overflow(); let one = I64::try_from(1u64).unwrap(); - let max = I64::max(); + let max = I64::MAX; - assert(max + one == I64::min()); + assert(max + one == I64::MIN); } #[test] @@ -312,14 +346,14 @@ fn signed_i64_subtract() { assert(res8 == I64::neg_try_from(1).unwrap()); // Edge Cases - let res11 = I64::zero() - (I64::min() + I64::try_from(1).unwrap()); - assert(res11 == I64::max()); + let res11 = I64::zero() - (I64::MIN + I64::try_from(1).unwrap()); + assert(res11 == I64::MAX); - let res12 = I64::max() - I64::zero(); - assert(res12 == I64::max()); + let res12 = I64::MAX - I64::zero(); + assert(res12 == I64::MAX); - let res13 = I64::min() - I64::zero(); - assert(res13 == I64::min()); + let res13 = I64::MIN - I64::zero(); + assert(res13 == I64::MIN); let res14 = I64::zero() - I64::zero(); assert(res14 == I64::zero()); @@ -327,7 +361,7 @@ fn signed_i64_subtract() { #[test(should_revert)] fn revert_signed_i64_sub() { - let min = I64::min(); + let min = I64::MIN; let one = I64::try_from(1u64).unwrap(); let _ = min - one; @@ -335,7 +369,7 @@ fn revert_signed_i64_sub() { #[test(should_revert)] fn revert_signed_i64_sub_negative() { - let max = I64::max(); + let max = I64::MAX; let neg_one = I64::neg_try_from(1u64).unwrap(); let _ = max - neg_one; @@ -345,7 +379,7 @@ fn revert_signed_i64_sub_negative() { fn revert_signed_i64_sub_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let min = I64::min(); + let min = I64::MIN; let one = I64::try_from(1u64).unwrap(); let _ = min - one; @@ -355,11 +389,11 @@ fn revert_signed_i64_sub_unsafe_math() { fn signed_i64_sub_underflow() { let _ = disable_panic_on_overflow(); - let min = I64::min(); + let min = I64::MIN; let one = I64::try_from(1u64).unwrap(); let result = min - one; - assert(result == I64::max()); + assert(result == I64::MAX); } #[test] @@ -404,10 +438,10 @@ fn signed_i64_multiply() { assert(res10 == I64::try_from(2).unwrap()); // Edge Cases - let res12 = I64::max() * I64::zero(); + let res12 = I64::MAX * I64::zero(); assert(res12 == I64::zero()); - let res13 = I64::min() * I64::zero(); + let res13 = I64::MIN * I64::zero(); assert(res13 == I64::zero()); let res14 = I64::zero() * I64::zero(); @@ -416,7 +450,7 @@ fn signed_i64_multiply() { #[test(should_revert)] fn revert_signed_i64_mul() { - let max = I64::max(); + let max = I64::MAX; let two = I64::try_from(2u64).unwrap(); let _ = max * two; @@ -424,7 +458,7 @@ fn revert_signed_i64_mul() { #[test(should_revert)] fn revert_signed_i64_mul_negatice() { - let max = I64::max(); + let max = I64::MAX; let two = I64::neg_try_from(2u64).unwrap(); let _ = max * two; @@ -434,7 +468,7 @@ fn revert_signed_i64_mul_negatice() { fn revert_signed_i64_mul_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let max = I64::max(); + let max = I64::MAX; let two = I64::try_from(2u64).unwrap(); let _ = max * two; @@ -444,7 +478,7 @@ fn revert_signed_i64_mul_unsafe_math() { fn signed_i64_mul() { let _ = disable_panic_on_overflow(); - let max = I64::max(); + let max = I64::MAX; let two = I64::try_from(2u64).unwrap(); let result = max * two; @@ -493,10 +527,10 @@ fn signed_i64_divide() { assert(res10 == I64::try_from(2).unwrap()); // Edge Cases - let res12 = I64::zero() / I64::max(); + let res12 = I64::zero() / I64::MAX; assert(res12 == I64::zero()); - let res13 = I64::zero() / I64::min(); + let res13 = I64::zero() / I64::MIN; assert(res13 == I64::zero()); } @@ -540,9 +574,9 @@ fn signed_i64_wrapping_neg() { let ninty_three = I64::try_from(93u64).unwrap(); let neg_ninty_three = I64::neg_try_from(93u64).unwrap(); let zero = I64::try_from(0u64).unwrap(); - let max = I64::max(); - let min = I64::min(); - let neg_min_plus_one = I64::min() + I64::try_from(1u64).unwrap(); + let max = I64::MAX; + let min = I64::MIN; + let neg_min_plus_one = I64::MIN + I64::try_from(1u64).unwrap(); let res1 = one.wrapping_neg(); let res2 = neg_one.wrapping_neg(); @@ -598,7 +632,7 @@ fn signed_i64_try_from_u64() { fn signed_i64_try_into_u64() { let zero = I64::zero(); let negative = I64::neg_try_from(1).unwrap(); - let max = I64::max(); + let max = I64::MAX; let indent: u64 = I64::indent(); let u64_max_try_into: Option = max.try_into(); @@ -617,7 +651,7 @@ fn signed_i64_try_into_u64() { fn signed_i64_u64_try_from() { let zero = I64::zero(); let negative = I64::neg_try_from(1).unwrap(); - let max = I64::max(); + let max = I64::MAX; let indent: u64 = I64::indent(); let u64_max_try_from: Option = u64::try_from(max); @@ -638,7 +672,7 @@ fn signed_i64_u64_try_into() { let i64_max_try_into: Option = (indent - 1).try_into(); assert(i64_max_try_into.is_some()); - assert(i64_max_try_into.unwrap() == I64::max()); + assert(i64_max_try_into.unwrap() == I64::MAX); let i64_min_try_into: Option = u64::min().try_into(); assert(i64_min_try_into.is_some()); diff --git a/tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw deleted file mode 100644 index 59a639ad..00000000 --- a/tests/src/signed_integers/signed_i64_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i64::I64; - -fn main() -> bool { - let one = I64::try_from(1u64).unwrap(); - let neg_one = I64::neg_try_from(1u64).unwrap(); - - let two = I64::try_from(2u64).unwrap(); - let neg_two = I64::neg_try_from(2u64).unwrap(); - - let ten = I64::try_from(10u64).unwrap(); - let neg_ten = I64::neg_try_from(10u64).unwrap(); - - let twenty_seven = I64::try_from(27u64).unwrap(); - let neg_twenty_seven = I64::neg_try_from(27u64).unwrap(); - - let ninty_three = I64::try_from(93u64).unwrap(); - let neg_ninty_three = I64::neg_try_from(93u64).unwrap(); - - let zero = I64::try_from(0u64).unwrap(); - let max = I64::MAX; - let min = I64::MIN; - let neg_min_plus_one = I64::MIN + I64::try_from(1).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} diff --git a/tests/src/signed_integers/signed_i8/src/main.sw b/tests/src/signed_integers/signed_i8/src/main.sw index 26316d1a..968cc7a8 100644 --- a/tests/src/signed_integers/signed_i8/src/main.sw +++ b/tests/src/signed_integers/signed_i8/src/main.sw @@ -15,10 +15,10 @@ fn signed_i8_eq() { let i8_2 = I8::zero(); let i8_3 = I8::try_from(1u8).unwrap(); let i8_4 = I8::try_from(1u8).unwrap(); - let i8_5 = I8::max(); - let i8_6 = I8::max(); - let i8_7 = I8::min(); - let i8_8 = I8::min(); + let i8_5 = I8::MAX; + let i8_6 = I8::MAX; + let i8_7 = I8::MIN; + let i8_8 = I8::MIN; let i8_9 = I8::neg_try_from(1u8).unwrap(); let i8_10 = I8::neg_try_from(1u8).unwrap(); @@ -49,10 +49,10 @@ fn signed_i8_ord() { let i8_2 = I8::zero(); let i8_3 = I8::try_from(1u8).unwrap(); let i8_4 = I8::try_from(1u8).unwrap(); - let i8_5 = I8::max(); - let i8_6 = I8::max(); - let i8_7 = I8::min(); - let i8_8 = I8::min(); + let i8_5 = I8::MAX; + let i8_6 = I8::MAX; + let i8_7 = I8::MIN; + let i8_8 = I8::MIN; let i8_9 = I8::neg_try_from(1u8).unwrap(); let i8_10 = I8::neg_try_from(1u8).unwrap(); @@ -99,6 +99,40 @@ fn signed_i8_ord() { assert(i8_9 > i8_7); } +#[test] +fn signed_i8_total_ord() { + let zero = I8::zero(); + let one = I8::try_from(1u8).unwrap(); + let max_1 = I8::MAX; + let min_1 = I8::MIN; + let neg_one_1 = I8::neg_try_from(1u8).unwrap(); + + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); + + assert(max_1.min(one) == one); + assert(max_1.max(one) == max_1); + assert(one.min(max_1) == one); + assert(one.max(max_1) == max_1); + + assert(min_1.min(one) == min_1); + assert(min_1.max(one) == one); + assert(one.min(min_1) == min_1); + assert(one.max(min_1) == one); + + assert(max_1.min(min_1) == min_1); + assert(max_1.max(min_1) == max_1); + assert(min_1.min(max_1) == min_1); + assert(min_1.max(max_1) == max_1); + + assert(neg_one_1.min(one) == neg_one_1); + assert(neg_one_1.max(one) == one); + assert(one.min(neg_one_1) == neg_one_1); + assert(one.max(neg_one_1) == one); +} + #[test] fn signed_i8_bits() { assert(I8::bits() == 8); @@ -116,14 +150,14 @@ fn signed_i8_from_uint() { } #[test] -fn signed_i8_max() { - let max = I8::max(); +fn signed_i8_max_constant() { + let max = I8::MAX; assert(max.underlying() == u8::max()); } #[test] -fn signed_i8_min() { - let max = I8::min(); +fn signed_i8_min_constant() { + let max = I8::MIN; assert(max.underlying() == u8::min()); } @@ -167,7 +201,7 @@ fn signed_i8_is_zero() { assert(zero.is_zero()); let other_1 = I8::from_uint(1); - let other_2 = I8::max(); + let other_2 = I8::MAX; assert(!other_1.is_zero()); assert(!other_2.is_zero()); } @@ -227,14 +261,14 @@ fn signed_i8_add() { assert(res10 == I8::neg_try_from(3).unwrap()); // Edge Cases - let res11 = I8::min() + I8::max(); + let res11 = I8::MIN + I8::MAX; assert(res11 == I8::neg_try_from(1).unwrap()); - let res12 = I8::max() + I8::zero(); - assert(res12 == I8::max()); + let res12 = I8::MAX + I8::zero(); + assert(res12 == I8::MAX); - let res13 = I8::min() + I8::zero(); - assert(res13 == I8::min()); + let res13 = I8::MIN + I8::zero(); + assert(res13 == I8::MIN); let res14 = I8::zero() + I8::zero(); assert(res14 == I8::zero()); @@ -243,7 +277,7 @@ fn signed_i8_add() { #[test(should_revert)] fn revert_signed_i8_add() { let one = I8::try_from(1u8).unwrap(); - let max = I8::max(); + let max = I8::MAX; let _ = max + one; } @@ -251,7 +285,7 @@ fn revert_signed_i8_add() { #[test(should_revert)] fn revert_signed_i8_add_negative() { let neg_one = I8::neg_try_from(1u8).unwrap(); - let min = I8::min(); + let min = I8::MIN; let _ = min + neg_one; } @@ -261,7 +295,7 @@ fn revert_signed_i8_add_unsafe_math() { let _ = disable_panic_on_unsafe_math(); let one = I8::try_from(1u8).unwrap(); - let max = I8::max(); + let max = I8::MAX; let _ = max + one; } @@ -271,9 +305,9 @@ fn signed_i8_add_overflow() { let _ = disable_panic_on_overflow(); let one = I8::try_from(1u8).unwrap(); - let max = I8::max(); + let max = I8::MAX; - assert(max + one == I8::min()); + assert(max + one == I8::MIN); } #[test] @@ -312,14 +346,14 @@ fn signed_i8_subtract() { assert(res8 == I8::neg_try_from(1).unwrap()); // Edge Cases - let res11 = I8::zero() - (I8::min() + I8::try_from(1).unwrap()); - assert(res11 == I8::max()); + let res11 = I8::zero() - (I8::MIN + I8::try_from(1).unwrap()); + assert(res11 == I8::MAX); - let res12 = I8::max() - I8::zero(); - assert(res12 == I8::max()); + let res12 = I8::MAX - I8::zero(); + assert(res12 == I8::MAX); - let res13 = I8::min() - I8::zero(); - assert(res13 == I8::min()); + let res13 = I8::MIN - I8::zero(); + assert(res13 == I8::MIN); let res14 = I8::zero() - I8::zero(); assert(res14 == I8::zero()); @@ -327,7 +361,7 @@ fn signed_i8_subtract() { #[test(should_revert)] fn revert_signed_i8_sub() { - let min = I8::min(); + let min = I8::MIN; let one = I8::try_from(1u8).unwrap(); let _ = min - one; @@ -335,7 +369,7 @@ fn revert_signed_i8_sub() { #[test(should_revert)] fn revert_signed_i8_sub_negative() { - let max = I8::max(); + let max = I8::MAX; let neg_one = I8::neg_try_from(1u8).unwrap(); let _ = max - neg_one; @@ -345,7 +379,7 @@ fn revert_signed_i8_sub_negative() { fn revert_signed_i8_sub_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let min = I8::min(); + let min = I8::MIN; let one = I8::try_from(1u8).unwrap(); let _ = min - one; @@ -355,11 +389,11 @@ fn revert_signed_i8_sub_unsafe_math() { fn signed_i8_sub_underflow() { let _ = disable_panic_on_overflow(); - let min = I8::min(); + let min = I8::MIN; let one = I8::try_from(1u8).unwrap(); let result = min - one; - assert(result == I8::max()); + assert(result == I8::MAX); } #[test] @@ -404,10 +438,10 @@ fn signed_i8_multiply() { assert(res10 == I8::try_from(2).unwrap()); // Edge Cases - let res12 = I8::max() * I8::zero(); + let res12 = I8::MAX * I8::zero(); assert(res12 == I8::zero()); - let res13 = I8::min() * I8::zero(); + let res13 = I8::MIN * I8::zero(); assert(res13 == I8::zero()); let res14 = I8::zero() * I8::zero(); @@ -416,7 +450,7 @@ fn signed_i8_multiply() { #[test(should_revert)] fn revert_signed_i8_mul() { - let max = I8::max(); + let max = I8::MAX; let two = I8::try_from(2u8).unwrap(); let _ = max * two; @@ -424,7 +458,7 @@ fn revert_signed_i8_mul() { #[test(should_revert)] fn revert_signed_i8_mul_negatice() { - let max = I8::max(); + let max = I8::MAX; let two = I8::neg_try_from(2u8).unwrap(); let _ = max * two; @@ -434,7 +468,7 @@ fn revert_signed_i8_mul_negatice() { fn revert_signed_i8_mul_unsafe_math() { let _ = disable_panic_on_unsafe_math(); - let max = I8::max(); + let max = I8::MAX; let two = I8::try_from(2u8).unwrap(); let _ = max * two; @@ -444,7 +478,7 @@ fn revert_signed_i8_mul_unsafe_math() { fn signed_i8_mul() { let _ = disable_panic_on_overflow(); - let max = I8::max(); + let max = I8::MAX; let two = I8::try_from(2u8).unwrap(); let result = max * two; @@ -493,10 +527,10 @@ fn signed_i8_divide() { assert(res10 == I8::try_from(2).unwrap()); // Edge Cases - let res12 = I8::zero() / I8::max(); + let res12 = I8::zero() / I8::MAX; assert(res12 == I8::zero()); - let res13 = I8::zero() / I8::min(); + let res13 = I8::zero() / I8::MIN; assert(res13 == I8::zero()); } @@ -540,9 +574,9 @@ fn signed_i8_wrapping_neg() { let ninty_three = I8::try_from(93u8).unwrap(); let neg_ninty_three = I8::neg_try_from(93u8).unwrap(); let zero = I8::try_from(0u8).unwrap(); - let max = I8::max(); - let min = I8::min(); - let neg_min_plus_one = I8::min() + I8::try_from(1u8).unwrap(); + let max = I8::MAX; + let min = I8::MIN; + let neg_min_plus_one = I8::MIN + I8::try_from(1u8).unwrap(); let res1 = one.wrapping_neg(); let res2 = neg_one.wrapping_neg(); @@ -598,7 +632,7 @@ fn signed_i8_try_from_u8() { fn signed_i8_try_into_u8() { let zero = I8::zero(); let negative = I8::neg_try_from(1).unwrap(); - let max = I8::max(); + let max = I8::MAX; let indent: u8 = I8::indent(); let u8_max_try_into: Option = max.try_into(); @@ -617,7 +651,7 @@ fn signed_i8_try_into_u8() { fn signed_i8_u8_try_from() { let zero = I8::zero(); let negative = I8::neg_try_from(1).unwrap(); - let max = I8::max(); + let max = I8::MAX; let indent: u8 = I8::indent(); let u8_max_try_from: Option = u8::try_from(max); @@ -638,7 +672,7 @@ fn signed_i8_u8_try_into() { let i8_max_try_into: Option = (indent - 1).try_into(); assert(i8_max_try_into.is_some()); - assert(i8_max_try_into.unwrap() == I8::max()); + assert(i8_max_try_into.unwrap() == I8::MAX); let i8_min_try_into: Option = u8::min().try_into(); assert(i8_min_try_into.is_some()); diff --git a/tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw b/tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw deleted file mode 100644 index e5aa16b4..00000000 --- a/tests/src/signed_integers/signed_i8_wrapping_neg/src/main.sw +++ /dev/null @@ -1,60 +0,0 @@ -script; - -use sway_libs::signed_integers::i8::I8; - -fn main() -> bool { - let one = I8::try_from(1u8).unwrap(); - let neg_one = I8::neg_try_from(1u8).unwrap(); - - let two = I8::try_from(2u8).unwrap(); - let neg_two = I8::neg_try_from(2u8).unwrap(); - - let ten = I8::try_from(10u8).unwrap(); - let neg_ten = I8::neg_try_from(10u8).unwrap(); - - let twenty_seven = I8::try_from(27u8).unwrap(); - let neg_twenty_seven = I8::neg_try_from(27u8).unwrap(); - - let ninty_three = I8::try_from(93u8).unwrap(); - let neg_ninty_three = I8::neg_try_from(93u8).unwrap(); - - let zero = I8::try_from(0u8).unwrap(); - let max = I8::MAX; - let min = I8::MIN; - let neg_min_plus_one = I8::MIN + I8::try_from(1u8).unwrap(); - - let res1 = one.wrapping_neg(); - let res2 = neg_one.wrapping_neg(); - assert(res1 == neg_one); - assert(res2 == one); - - let res3 = two.wrapping_neg(); - let res4 = neg_two.wrapping_neg(); - assert(res3 == neg_two); - assert(res4 == two); - - let res5 = ten.wrapping_neg(); - let res6 = neg_ten.wrapping_neg(); - assert(res5 == neg_ten); - assert(res6 == ten); - - let res7 = twenty_seven.wrapping_neg(); - let res8 = neg_twenty_seven.wrapping_neg(); - assert(res7 == neg_twenty_seven); - assert(res8 == twenty_seven); - - let res9 = ninty_three.wrapping_neg(); - let res10 = neg_ninty_three.wrapping_neg(); - assert(res9 == neg_ninty_three); - assert(res10 == ninty_three); - - let res11 = zero.wrapping_neg(); - let res12 = max.wrapping_neg(); - let res13 = min.wrapping_neg(); - - assert(res11 == zero); - assert(res12 == neg_min_plus_one); - assert(res13 == min); - - true -} From 194aa827de8da09ceed0ef8bd6d40fffda24d6e8 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Mon, 10 Mar 2025 09:46:31 -0300 Subject: [PATCH 09/13] Run formatter --- tests/src/signed_integers/signed_i128/src/main.sw | 6 +++--- tests/src/signed_integers/signed_i16/src/main.sw | 2 +- tests/src/signed_integers/signed_i256/src/main.sw | 2 +- tests/src/signed_integers/signed_i32/src/main.sw | 2 +- tests/src/signed_integers/signed_i64/src/main.sw | 2 +- tests/src/signed_integers/signed_i8/src/main.sw | 2 +- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/src/signed_integers/signed_i128/src/main.sw b/tests/src/signed_integers/signed_i128/src/main.sw index 2a00d247..573960b5 100644 --- a/tests/src/signed_integers/signed_i128/src/main.sw +++ b/tests/src/signed_integers/signed_i128/src/main.sw @@ -140,11 +140,11 @@ fn signed_i128_ord() { #[test] fn signed_i128_total_ord() { let zero = I128::zero(); - let one = I128::try_from(U128::from((0,1))).unwrap(); + let one = I128::try_from(U128::from((0, 1))).unwrap(); let max_1 = I128::MAX; let min_1 = I128::MIN; - let neg_one_1 = I128::neg_try_from(U128::from((0,1))).unwrap(); - + let neg_one_1 = I128::neg_try_from(U128::from((0, 1))).unwrap(); + assert(zero.min(one) == zero); assert(zero.max(one) == one); assert(one.min(zero) == zero); diff --git a/tests/src/signed_integers/signed_i16/src/main.sw b/tests/src/signed_integers/signed_i16/src/main.sw index 1774bb13..cb17a2dc 100644 --- a/tests/src/signed_integers/signed_i16/src/main.sw +++ b/tests/src/signed_integers/signed_i16/src/main.sw @@ -106,7 +106,7 @@ fn signed_i16_total_ord() { let max_1 = I16::MAX; let min_1 = I16::MIN; let neg_one_1 = I16::neg_try_from(1u16).unwrap(); - + assert(zero.min(one) == zero); assert(zero.max(one) == one); assert(one.min(zero) == zero); diff --git a/tests/src/signed_integers/signed_i256/src/main.sw b/tests/src/signed_integers/signed_i256/src/main.sw index 61d58662..98ae9b7e 100644 --- a/tests/src/signed_integers/signed_i256/src/main.sw +++ b/tests/src/signed_integers/signed_i256/src/main.sw @@ -108,7 +108,7 @@ fn signed_i256_total_ord() { let max_1 = I256::MAX; let min_1 = I256::MIN; let neg_one_1 = I256::neg_try_from(0x01u256).unwrap(); - + assert(zero.min(one) == zero); assert(zero.max(one) == one); assert(one.min(zero) == zero); diff --git a/tests/src/signed_integers/signed_i32/src/main.sw b/tests/src/signed_integers/signed_i32/src/main.sw index 27b8da57..8d348cca 100644 --- a/tests/src/signed_integers/signed_i32/src/main.sw +++ b/tests/src/signed_integers/signed_i32/src/main.sw @@ -106,7 +106,7 @@ fn signed_i32_total_ord() { let max_1 = I32::MAX; let min_1 = I32::MIN; let neg_one_1 = I32::neg_try_from(1u32).unwrap(); - + assert(zero.min(one) == zero); assert(zero.max(one) == one); assert(one.min(zero) == zero); diff --git a/tests/src/signed_integers/signed_i64/src/main.sw b/tests/src/signed_integers/signed_i64/src/main.sw index f5f36c31..23c4d55b 100644 --- a/tests/src/signed_integers/signed_i64/src/main.sw +++ b/tests/src/signed_integers/signed_i64/src/main.sw @@ -106,7 +106,7 @@ fn signed_i64_total_ord() { let max_1 = I64::MAX; let min_1 = I64::MIN; let neg_one_1 = I64::neg_try_from(1u64).unwrap(); - + assert(zero.min(one) == zero); assert(zero.max(one) == one); assert(one.min(zero) == zero); diff --git a/tests/src/signed_integers/signed_i8/src/main.sw b/tests/src/signed_integers/signed_i8/src/main.sw index 968cc7a8..086a0d8e 100644 --- a/tests/src/signed_integers/signed_i8/src/main.sw +++ b/tests/src/signed_integers/signed_i8/src/main.sw @@ -106,7 +106,7 @@ fn signed_i8_total_ord() { let max_1 = I8::MAX; let min_1 = I8::MIN; let neg_one_1 = I8::neg_try_from(1u8).unwrap(); - + assert(zero.min(one) == zero); assert(zero.max(one) == one); assert(one.min(zero) == zero); From f246f638d679ad825d9d0c02690e71c4c019c54d Mon Sep 17 00:00:00 2001 From: bitzoic Date: Mon, 10 Mar 2025 09:49:05 -0300 Subject: [PATCH 10/13] Update CHANGELOG --- CHANGELOG.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5c857dbb..5eda8b29 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,15 +12,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/). - [#312](https://github.com/FuelLabs/sway-libs/pull/312) Implements `TotalOrd` trait for `I8`, `I16`, `I32`, `I64`, `I128`, and `I256`. - [#326](https://github.com/FuelLabs/sway-libs/pull/326) Introduces the Big Integers Library with the `BigUint` type. - [#329](https://github.com/FuelLabs/sway-libs/pull/329) Introduce the Sparse Merkle Proof Library. +- [#332](https://github.com/FuelLabs/sway-libs/pull/332) Adds additional tests for signed integers. ### Changed - [#327](https://github.com/FuelLabs/sway-libs/pull/327) Updates the repository to forc `v0.66.7`, fuel-core `v0.41.4`, and fuels `v0.70.0`. +- [#332](https://github.com/FuelLabs/sway-libs/pull/332) Update all tests for signed integers to inline tests. ### Fixed -- Some fix here 1 -- Some fix here 2 +- [#332](https://github.com/FuelLabs/sway-libs/pull/332) Fixes signed integers to not revert when unsafe math and overflow is enabled. ### Breaking From a56fd89f8cb5dbd8edd0392cb290b148a2ffac27 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Mon, 10 Mar 2025 09:51:06 -0300 Subject: [PATCH 11/13] Update Forc.lock --- tests/Forc.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/Forc.lock b/tests/Forc.lock index d138d37f..8cb09189 100644 --- a/tests/Forc.lock +++ b/tests/Forc.lock @@ -30,7 +30,7 @@ dependencies = ["std"] [[package]] name = "core" -source = "path+from-root-2005F6931E5DB2F8" +source = "path+from-root-DD4F12EBC39CAB5B" [[package]] name = "i128_test" @@ -204,7 +204,7 @@ dependencies = ["std"] [[package]] name = "std" -source = "git+https://github.com/fuellabs/sway?rev#be5ecbd69249aa62eaa5fd7fb6c5bee347956b69" +source = "git+https://github.com/fuellabs/sway?tag=v0.66.7#5ed7cec6dbcd42f0c2f84df8511a4c0007b1902e" dependencies = ["core"] [[package]] From d322b83dd94d8f40812e027db9dd7fa45df8ff04 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Mon, 10 Mar 2025 10:09:26 -0300 Subject: [PATCH 12/13] Update for older version of sway --- tests/src/signed_integers/signed_i128/src/main.sw | 12 ++++++------ tests/src/signed_integers/signed_i16/src/main.sw | 12 ++++++------ tests/src/signed_integers/signed_i256/src/main.sw | 12 ++++++------ tests/src/signed_integers/signed_i32/src/main.sw | 13 ++++++------- tests/src/signed_integers/signed_i64/src/main.sw | 12 ++++++------ tests/src/signed_integers/signed_i8/src/main.sw | 12 ++++++------ 6 files changed, 36 insertions(+), 37 deletions(-) diff --git a/tests/src/signed_integers/signed_i128/src/main.sw b/tests/src/signed_integers/signed_i128/src/main.sw index 573960b5..a852f3c0 100644 --- a/tests/src/signed_integers/signed_i128/src/main.sw +++ b/tests/src/signed_integers/signed_i128/src/main.sw @@ -715,15 +715,15 @@ fn signed_i128_try_into_u128() { let max = I128::MAX; let indent: U128 = I128::indent(); - let U128_max_try_into: Option = max.try_into(); + let U128_max_try_into: Option = >::try_into(max); assert(U128_max_try_into.is_some()); assert(U128_max_try_into.unwrap() == indent - U128::from((0, 1))); - let U128_min_try_into: Option = zero.try_into(); + let U128_min_try_into: Option = >::try_into(zero); assert(U128_min_try_into.is_some()); assert(U128_min_try_into.unwrap() == U128::zero()); - let U128_overflow_try_into: Option = negative.try_into(); + let U128_overflow_try_into: Option = >::try_into(negative); assert(U128_overflow_try_into.is_none()); } @@ -750,14 +750,14 @@ fn signed_i128_u128_try_from() { fn signed_i128_u128_try_into() { let indent: U128 = I128::indent(); - let i128_max_try_into: Option = (indent - U128::from((0, 1))).try_into(); + let i128_max_try_into: Option = >::try_into((indent - U128::from((0, 1)))); assert(i128_max_try_into.is_some()); assert(i128_max_try_into.unwrap() == I128::MAX); - let i128_min_try_into: Option = U128::min().try_into(); + let i128_min_try_into: Option = >::try_into(U128::min()); assert(i128_min_try_into.is_some()); assert(i128_min_try_into.unwrap() == I128::zero()); - let i128_overflow_try_into: Option = indent.try_into(); + let i128_overflow_try_into: Option = >::try_into(indent); assert(i128_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i16/src/main.sw b/tests/src/signed_integers/signed_i16/src/main.sw index cb17a2dc..a1b757c3 100644 --- a/tests/src/signed_integers/signed_i16/src/main.sw +++ b/tests/src/signed_integers/signed_i16/src/main.sw @@ -635,15 +635,15 @@ fn signed_i16_try_into_u16() { let max = I16::MAX; let indent: u16 = I16::indent(); - let u16_max_try_into: Option = max.try_into(); + let u16_max_try_into: Option = >::try_into(max); assert(u16_max_try_into.is_some()); assert(u16_max_try_into.unwrap() == indent - 1); - let u16_min_try_into: Option = zero.try_into(); + let u16_min_try_into: Option = >::try_into(zero); assert(u16_min_try_into.is_some()); assert(u16_min_try_into.unwrap() == u16::zero()); - let u16_overflow_try_into: Option = negative.try_into(); + let u16_overflow_try_into: Option = >::try_into(negative); assert(u16_overflow_try_into.is_none()); } @@ -670,14 +670,14 @@ fn signed_i16_u16_try_from() { fn signed_i16_u16_try_into() { let indent: u16 = I16::indent(); - let i16_max_try_into: Option = (indent - 1).try_into(); + let i16_max_try_into: Option = >::try_into((indent - 1)); assert(i16_max_try_into.is_some()); assert(i16_max_try_into.unwrap() == I16::MAX); - let i16_min_try_into: Option = u16::min().try_into(); + let i16_min_try_into: Option = >::try_into(u16::min()); assert(i16_min_try_into.is_some()); assert(i16_min_try_into.unwrap() == I16::zero()); - let i16_overflow_try_into: Option = indent.try_into(); + let i16_overflow_try_into: Option = >::try_into(indent); assert(i16_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i256/src/main.sw b/tests/src/signed_integers/signed_i256/src/main.sw index 98ae9b7e..1263166a 100644 --- a/tests/src/signed_integers/signed_i256/src/main.sw +++ b/tests/src/signed_integers/signed_i256/src/main.sw @@ -646,15 +646,15 @@ fn signed_i256_try_into_u256() { let max = I256::MAX; let indent: u256 = I256::indent(); - let u256_max_try_into: Option = max.try_into(); + let u256_max_try_into: Option = >::try_into(max); assert(u256_max_try_into.is_some()); assert(u256_max_try_into.unwrap() == indent - 0x1u256); - let u256_min_try_into: Option = zero.try_into(); + let u256_min_try_into: Option = >::try_into(zero); assert(u256_min_try_into.is_some()); assert(u256_min_try_into.unwrap() == u256::zero()); - let u256_overflow_try_into: Option = negative.try_into(); + let u256_overflow_try_into: Option = >::try_into(negative); assert(u256_overflow_try_into.is_none()); } @@ -681,14 +681,14 @@ fn signed_i256_u256_try_from() { fn signed_i256_u256_try_into() { let indent: u256 = I256::indent(); - let i256_max_try_into: Option = (indent - 0x1u256).try_into(); + let i256_max_try_into: Option = >::try_into((indent - 0x1u256)); assert(i256_max_try_into.is_some()); assert(i256_max_try_into.unwrap() == I256::MAX); - let i256_min_try_into: Option = u256::min().try_into(); + let i256_min_try_into: Option = >::try_into(u256::min()); assert(i256_min_try_into.is_some()); assert(i256_min_try_into.unwrap() == I256::zero()); - let i256_overflow_try_into: Option = indent.try_into(); + let i256_overflow_try_into: Option = >::try_into(indent); assert(i256_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i32/src/main.sw b/tests/src/signed_integers/signed_i32/src/main.sw index 8d348cca..75282b59 100644 --- a/tests/src/signed_integers/signed_i32/src/main.sw +++ b/tests/src/signed_integers/signed_i32/src/main.sw @@ -393,7 +393,6 @@ fn signed_i32_sub_underflow() { let one = I32::try_from(1u32).unwrap(); let result = min - one; - log(result); assert(result == I32::MAX); } @@ -636,15 +635,15 @@ fn signed_i32_try_into_u32() { let max = I32::MAX; let indent: u32 = I32::indent(); - let u32_max_try_into: Option = max.try_into(); + let u32_max_try_into: Option = >::try_into(max); assert(u32_max_try_into.is_some()); assert(u32_max_try_into.unwrap() == indent - 1); - let u32_min_try_into: Option = zero.try_into(); + let u32_min_try_into: Option = >::try_into(zero); assert(u32_min_try_into.is_some()); assert(u32_min_try_into.unwrap() == u32::zero()); - let u32_overflow_try_into: Option = negative.try_into(); + let u32_overflow_try_into: Option = >::try_into(negative); assert(u32_overflow_try_into.is_none()); } @@ -671,14 +670,14 @@ fn signed_i32_u32_try_from() { fn signed_i32_u32_try_into() { let indent: u32 = I32::indent(); - let i32_max_try_into: Option = (indent - 1).try_into(); + let i32_max_try_into: Option = >::try_into((indent - 1)); assert(i32_max_try_into.is_some()); assert(i32_max_try_into.unwrap() == I32::MAX); - let i32_min_try_into: Option = u32::min().try_into(); + let i32_min_try_into: Option = >::try_into(u32::min()); assert(i32_min_try_into.is_some()); assert(i32_min_try_into.unwrap() == I32::zero()); - let i32_overflow_try_into: Option = indent.try_into(); + let i32_overflow_try_into: Option = >::try_into(indent); assert(i32_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i64/src/main.sw b/tests/src/signed_integers/signed_i64/src/main.sw index 23c4d55b..73b7251d 100644 --- a/tests/src/signed_integers/signed_i64/src/main.sw +++ b/tests/src/signed_integers/signed_i64/src/main.sw @@ -635,15 +635,15 @@ fn signed_i64_try_into_u64() { let max = I64::MAX; let indent: u64 = I64::indent(); - let u64_max_try_into: Option = max.try_into(); + let u64_max_try_into: Option = >::try_into(max); assert(u64_max_try_into.is_some()); assert(u64_max_try_into.unwrap() == indent - 1); - let u64_min_try_into: Option = zero.try_into(); + let u64_min_try_into: Option = >::try_into(zero); assert(u64_min_try_into.is_some()); assert(u64_min_try_into.unwrap() == u64::zero()); - let u64_overflow_try_into: Option = negative.try_into(); + let u64_overflow_try_into: Option = >::try_into(negative); assert(u64_overflow_try_into.is_none()); } @@ -670,14 +670,14 @@ fn signed_i64_u64_try_from() { fn signed_i64_u64_try_into() { let indent: u64 = I64::indent(); - let i64_max_try_into: Option = (indent - 1).try_into(); + let i64_max_try_into: Option = >::try_into((indent - 1)); assert(i64_max_try_into.is_some()); assert(i64_max_try_into.unwrap() == I64::MAX); - let i64_min_try_into: Option = u64::min().try_into(); + let i64_min_try_into: Option = >::try_into(u64::min()); assert(i64_min_try_into.is_some()); assert(i64_min_try_into.unwrap() == I64::zero()); - let i64_overflow_try_into: Option = indent.try_into(); + let i64_overflow_try_into: Option = >::try_into(indent); assert(i64_overflow_try_into.is_none()); } diff --git a/tests/src/signed_integers/signed_i8/src/main.sw b/tests/src/signed_integers/signed_i8/src/main.sw index 086a0d8e..df2b6541 100644 --- a/tests/src/signed_integers/signed_i8/src/main.sw +++ b/tests/src/signed_integers/signed_i8/src/main.sw @@ -635,15 +635,15 @@ fn signed_i8_try_into_u8() { let max = I8::MAX; let indent: u8 = I8::indent(); - let u8_max_try_into: Option = max.try_into(); + let u8_max_try_into: Option = >::try_into(max); assert(u8_max_try_into.is_some()); assert(u8_max_try_into.unwrap() == indent - 1); - let u8_min_try_into: Option = zero.try_into(); + let u8_min_try_into: Option = >::try_into(zero); assert(u8_min_try_into.is_some()); assert(u8_min_try_into.unwrap() == u8::zero()); - let u8_overflow_try_into: Option = negative.try_into(); + let u8_overflow_try_into: Option = >::try_into(negative); assert(u8_overflow_try_into.is_none()); } @@ -670,14 +670,14 @@ fn signed_i8_u8_try_from() { fn signed_i8_u8_try_into() { let indent: u8 = I8::indent(); - let i8_max_try_into: Option = (indent - 1).try_into(); + let i8_max_try_into: Option = >::try_into((indent - 1)); assert(i8_max_try_into.is_some()); assert(i8_max_try_into.unwrap() == I8::MAX); - let i8_min_try_into: Option = u8::min().try_into(); + let i8_min_try_into: Option = >::try_into(u8::min()); assert(i8_min_try_into.is_some()); assert(i8_min_try_into.unwrap() == I8::zero()); - let i8_overflow_try_into: Option = indent.try_into(); + let i8_overflow_try_into: Option = >::try_into(indent); assert(i8_overflow_try_into.is_none()); } From b1a8fbc6c18134d983bb96835238acd7ed173b19 Mon Sep 17 00:00:00 2001 From: bitzoic Date: Thu, 20 Mar 2025 14:55:17 -0300 Subject: [PATCH 13/13] Update CHANGELOG --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 24693f29..ab0d9b13 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ### Changed -- Some change here. +- [#332](https://github.com/FuelLabs/sway-libs/pull/332) Switches signed integer tests from SDK tests to inline tests. - Some change here. ### Fixed