diff --git a/CHANGELOG.md b/CHANGELOG.md index 571edcee..ab0d9b13 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,18 +9,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/). ### Added -- Some addition here. -- Some addition here. +- [#332](https://github.com/FuelLabs/sway-libs/pull/332) Adds additional arithmetic operation tests for signed integers. ### 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 -- Some fix here. -- Some fix here. +- [#332](https://github.com/FuelLabs/sway-libs/pull/332) Fixes signed integers to not revert when unsafe math and overflow is enabled. ### Breaking diff --git a/libs/src/signed_integers/i128.sw b/libs/src/signed_integers/i128.sw index d725b0a7..032ded35 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; @@ -308,7 +308,9 @@ impl Add for I128 { impl 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); + 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()) @@ -419,7 +421,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(), }) @@ -429,6 +431,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() { @@ -438,3 +450,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/libs/src/signed_integers/i16.sw b/libs/src/signed_integers/i16.sw index b5743a09..f53f5043 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; @@ -300,7 +300,10 @@ impl Add for I16 { impl 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() @@ -409,7 +412,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(), }) @@ -419,6 +422,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() { @@ -428,3 +441,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/libs/src/signed_integers/i256.sw b/libs/src/signed_integers/i256.sw index 883c79f8..0de56718 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; @@ -304,7 +304,10 @@ impl Add for I256 { impl 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(); @@ -400,7 +403,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(), }) @@ -410,6 +413,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() { @@ -419,3 +432,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/libs/src/signed_integers/i32.sw b/libs/src/signed_integers/i32.sw index f8c07810..b76c4f6f 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; @@ -358,7 +358,10 @@ impl Multiply for I32 { impl 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() @@ -409,7 +412,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(), }) @@ -419,6 +422,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() { @@ -428,3 +441,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/libs/src/signed_integers/i64.sw b/libs/src/signed_integers/i64.sw index aba98214..2ee52bdf 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; @@ -359,7 +359,10 @@ impl Multiply for I64 { impl 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() @@ -410,7 +413,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(), }) @@ -420,6 +423,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() { @@ -429,3 +442,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/libs/src/signed_integers/i8.sw b/libs/src/signed_integers/i8.sw index bd9ccce1..803a86db 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; @@ -300,7 +300,10 @@ impl Add for I8 { impl 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() @@ -409,7 +412,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(), }) @@ -419,6 +422,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() { @@ -428,3 +441,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/Forc.lock b/tests/Forc.lock index 0645e0a0..e040d3e2 100644 --- a/tests/Forc.lock +++ b/tests/Forc.lock @@ -36,14 +36,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i128_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i16_test" source = "member" @@ -52,14 +44,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i16_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i256_test" source = "member" @@ -68,14 +52,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i256_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i32_test" source = "member" @@ -84,14 +60,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i32_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i64_test" source = "member" @@ -100,14 +68,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i64_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "i8_test" source = "member" @@ -116,14 +76,6 @@ dependencies = [ "sway_libs", ] -[[package]] -name = "i8_wrapping_neg_test" -source = "member" -dependencies = [ - "std", - "sway_libs", -] - [[package]] name = "merkle_proof_test" source = "member" 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_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 1e0ebb7a..a852f3c0 100644 --- a/tests/src/signed_integers/signed_i128/src/main.sw +++ b/tests/src/signed_integers/signed_i128/src/main.sw @@ -1,41 +1,390 @@ -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_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); +} + +#[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_constant() { + let max = I128::MAX; + assert(max.underlying() == U128::max()); +} + +#[test] +fn signed_i128_min_constant() { + 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()); + + // First positive + let res3 = pos1 + neg1; + assert(res3 == I128::zero()); -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()); + let res4 = pos2 + neg1; + assert(res4 == I128::try_from(U128::from((0, 1))).unwrap()); - 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 res5 = pos1 + neg2; + assert(res5 == I128::neg_try_from(U128::from((0, 1))).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_res3 = upper1 + neg_upper1; + assert(upper_res3 == I128::zero()); - 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()); + let upper_res4 = upper2 + neg_upper1; + assert(upper_res4 == I128::try_from(U128::from((1, 0))).unwrap()); - let u128_lower_max_u64 = U128::from((0, u64::max())); + 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_lower_max_u64).unwrap(); - assert(res == I128::neg_try_from(u128_10).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 res8 = neg1 + pos2; + assert(res8 == I128::try_from(U128::from((0, 1))).unwrap()); + + let upper_res6 = neg_upper1 + upper1; + assert(upper_res6 == I128::zero()); + + let upper_res7 = neg_upper2 + upper1; + assert(upper_res7 == I128::neg_try_from(U128::from((1, 0))).unwrap()); + + 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()); + + let res10 = neg2 + neg1; + assert(res10 == I128::neg_try_from(U128::from((0, 3))).unwrap()); - let u128_5 = U128::from((0, 5)); + let upper_res9 = neg_upper1 + neg_upper2; + assert(upper_res9 == I128::neg_try_from(U128::from((3, 0))).unwrap()); - let u128_2 = U128::from((0, 2)); + 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()); +} + +#[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; +} - res = I128::try_from(u128_10).unwrap() / I128::try_from(u128_5).unwrap(); - assert(res == I128::try_from(u128_2).unwrap()); +#[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; - // Subtraction tests + 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 +392,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 +401,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 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; +} - let res6 = neg2 - neg1; +#[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 +704,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))); + 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 = >::try_into(max); + 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 = >::try_into(zero); + assert(U128_min_try_into.is_some()); + assert(U128_min_try_into.unwrap() == U128::zero()); - // Test into U128 + let U128_overflow_try_into: Option = >::try_into(negative); + 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,42 +744,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); - - 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 U128_overflow_try_into: Option = negative.try_into(); - assert(U128_overflow_try_into.is_none()); - - // TotalOrd tests - 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); +#[test] +fn signed_i128_u128_try_into() { + let indent: U128 = I128::indent(); - 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); + 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); - 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); + 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()); - true + let i128_overflow_try_into: Option = >::try_into(indent); + 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 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_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; - } -} 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 f1b6feff..a1b757c3 100644 --- a/tests/src/signed_integers/signed_i16/src/main.sw +++ b/tests/src/signed_integers/signed_i16/src/main.sw @@ -1,29 +1,317 @@ -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 { +#[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_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); +} + +#[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_constant() { + let max = I16::MAX; + assert(max.underlying() == u16::max()); +} + +#[test] +fn signed_i16_min_constant() { + 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()); + + let res5 = pos1 + neg2; + assert(res5 == I16::neg_try_from(1).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); + + 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_add() { let one = I16::try_from(1u16).unwrap(); - let mut res = one + I16::try_from(1u16).unwrap(); - assert(res == I16::try_from(2u16).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(11u16).unwrap(); - assert(res == I16::try_from(32767u16).unwrap()); +#[test(should_revert)] +fn revert_signed_i16_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); - res = I16::try_from(10u16).unwrap() * I16::neg_try_from(1u16).unwrap(); - assert(res == I16::neg_try_from(10u16).unwrap()); + let one = I16::try_from(1u16).unwrap(); + let max = I16::MAX; - res = I16::try_from(10u16).unwrap() * I16::try_from(10u16).unwrap(); - assert(res == I16::try_from(100u16).unwrap()); + let _ = max + one; +} - res = I16::try_from(10u16).unwrap() / I16::neg_try_from(1u16).unwrap(); - assert(res == I16::neg_try_from(10u16).unwrap()); +#[test] +fn signed_i16_add_overflow() { + let _ = disable_panic_on_overflow(); - res = I16::try_from(10u16).unwrap() / I16::try_from(5u16).unwrap(); - assert(res == I16::try_from(2u16).unwrap()); + let one = I16::try_from(1u16).unwrap(); + let max = I16::MAX; + + assert(max + one == I16::MIN); +} - // Subtraction tests +#[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 +319,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 +328,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 +624,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); + 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 = >::try_into(max); + 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 = >::try_into(zero); + assert(u16_min_try_into.is_some()); + assert(u16_min_try_into.unwrap() == u16::zero()); - // Test into u16 + let u16_overflow_try_into: Option = >::try_into(negative); + 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,43 +664,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); - - 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 u16_overflow_try_into: Option = negative.try_into(); - assert(u16_overflow_try_into.is_none()); - - // TotalOrd tests - 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); +#[test] +fn signed_i16_u16_try_into() { + let indent: u16 = I16::indent(); - 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); + 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); - 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); + 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()); - true + let i16_overflow_try_into: Option = >::try_into(indent); + 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 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_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; - } -} 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 91948663..1263166a 100644 --- a/tests/src/signed_integers/signed_i256/src/main.sw +++ b/tests/src/signed_integers/signed_i256/src/main.sw @@ -1,157 +1,633 @@ -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_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(); - // Second positive - let res4 = neg1 - pos1; - assert(res4 == I256::neg_try_from(u256_two).unwrap()); + assert(zero.min(one) == zero); + assert(zero.max(one) == one); + assert(one.min(zero) == zero); + assert(one.max(zero) == one); - // Both negative - let res5 = neg1 - neg2; - assert(res5 == I256::try_from(u256_one).unwrap()); + 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); - let res6 = neg2 - neg1; - assert(res6 == I256::neg_try_from(u256_one).unwrap()); + 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); - // 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(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); +} + +#[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()); + + assert(zero.underlying() == u256::zero()); + assert(one.underlying() == 0x1u256); + assert(max.underlying() == u256::max()); +} + +#[test] +fn signed_i256_max_constant() { + let max = I256::MAX; + assert(max.underlying() == u256::max()); +} + +#[test] +fn signed_i256_min_constant() { + 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(); - // Test into I256 + 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(); + + // 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 +635,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); + 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 = >::try_into(max); + 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 = >::try_into(zero); + assert(u256_min_try_into.is_some()); + assert(u256_min_try_into.unwrap() == u256::zero()); + + let u256_overflow_try_into: Option = >::try_into(negative); + assert(u256_overflow_try_into.is_none()); +} - // Test into u256 +#[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,42 +675,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); - - 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 u256_overflow_try_into: Option = negative.try_into(); - assert(u256_overflow_try_into.is_none()); - - // TotalOrd tests - 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); +#[test] +fn signed_i256_u256_try_into() { + let indent: u256 = I256::indent(); - 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); + 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); - 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); + 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()); - true + let i256_overflow_try_into: Option = >::try_into(indent); + 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 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_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; - } -} 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 f646d967..75282b59 100644 --- a/tests/src/signed_integers/signed_i32/src/main.sw +++ b/tests/src/signed_integers/signed_i32/src/main.sw @@ -1,29 +1,317 @@ -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 { +#[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_total_ord() { + let zero = I32::zero(); let one = I32::try_from(1u32).unwrap(); - let mut res = one + I32::try_from(1u32).unwrap(); - assert(res == I32::try_from(2u32).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); +} + +#[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_constant() { + let max = I32::MAX; + assert(max.underlying() == u32::max()); +} + +#[test] +fn signed_i32_min_constant() { + 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()); +} - res = I32::try_from(10u32).unwrap() - I32::try_from(11u32).unwrap(); - assert(res == I32::try_from(2147483647u32).unwrap()); +#[test] +fn signed_i32_new() { + let new = I32::new(); - res = I32::try_from(10u32).unwrap() * I32::try_from(1u32).unwrap(); - assert(res == I32::neg_try_from(10u32).unwrap()); + assert(new.underlying() == 2147483648u32); +} - res = I32::try_from(10u32).unwrap() * I32::try_from(10u32).unwrap(); - assert(res == I32::try_from(100u32).unwrap()); +#[test] +fn signed_i32_zero() { + let zero = I32::zero(); - res = I32::try_from(10u32).unwrap() / I32::neg_try_from(1u32).unwrap(); - assert(res == I32::neg_try_from(10u32).unwrap()); + assert(zero.underlying() == 2147483648u32); +} - res = I32::try_from(10u32).unwrap() / I32::try_from(5u32).unwrap(); - assert(res == I32::try_from(2u32).unwrap()); +#[test] +fn signed_i32_is_zero() { + let zero = I32::zero(); + assert(zero.is_zero()); - // Subtraction Tests + 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()); + + let res5 = pos1 + neg2; + assert(res5 == I32::neg_try_from(1).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); + + 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_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; +} + +#[test(should_revert)] +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 + 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 +319,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 +328,295 @@ 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; + 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 +624,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); + 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 = >::try_into(max); + 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 = >::try_into(zero); + assert(u32_min_try_into.is_some()); + assert(u32_min_try_into.unwrap() == u32::zero()); - // Test into u32 + let u32_overflow_try_into: Option = >::try_into(negative); + 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,42 +664,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); - - 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()); - - // TotalOrd tests - 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); +#[test] +fn signed_i32_u32_try_into() { + let indent: u32 = I32::indent(); - 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); + 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); - 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); + 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()); - true + let i32_overflow_try_into: Option = >::try_into(indent); + 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 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_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; - } -} 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 f7efa40d..73b7251d 100644 --- a/tests/src/signed_integers/signed_i64/src/main.sw +++ b/tests/src/signed_integers/signed_i64/src/main.sw @@ -1,28 +1,317 @@ -script; +library; use sway_libs::signed_integers::i64::I64; use std::convert::*; +use std::flags::{disable_panic_on_overflow, disable_panic_on_unsafe_math}; + +#[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_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); +} + +#[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_constant() { + let max = I64::MAX; + assert(max.underlying() == u64::max()); +} + +#[test] +fn signed_i64_min_constant() { + 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 max = I64::MAX; + + let _ = max + one; +} + +#[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; +} + +#[test(should_revert)] +fn revert_signed_i64_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); -fn main() -> bool { 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; - 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()); + let _ = max + one; +} - res = I64::try_from(10u64).unwrap() * I64::try_from(10u64).unwrap(); - assert(res == I64::try_from(100u64).unwrap()); +#[test] +fn signed_i64_add_overflow() { + let _ = disable_panic_on_overflow(); - 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; - res = I64::try_from(10u64).unwrap() / I64::try_from(5u64).unwrap(); - assert(res == I64::try_from(2u64).unwrap()); + 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 +319,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 +328,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 +624,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); + 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 = >::try_into(max); + 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 = >::try_into(zero); + assert(u64_min_try_into.is_some()); + assert(u64_min_try_into.unwrap() == u64::zero()); - // Test into u64 + let u64_overflow_try_into: Option = >::try_into(negative); + 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,42 +664,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); - - 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 u64_overflow_try_into: Option = negative.try_into(); - assert(u64_overflow_try_into.is_none()); - - // TotalOrd tests - 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); +#[test] +fn signed_i64_u64_try_into() { + let indent: u64 = I64::indent(); - 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); + 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); - 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); + 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()); - true + let i64_overflow_try_into: Option = >::try_into(indent); + 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 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_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; - } -} 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 ea77bc5a..df2b6541 100644 --- a/tests/src/signed_integers/signed_i8/src/main.sw +++ b/tests/src/signed_integers/signed_i8/src/main.sw @@ -1,29 +1,317 @@ -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 { +#[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_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); +} + +#[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_constant() { + let max = I8::MAX; + assert(max.underlying() == u8::max()); +} + +#[test] +fn signed_i8_min_constant() { + 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()); + + let res5 = pos1 + neg2; + assert(res5 == I8::neg_try_from(1).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); + + 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_add() { let one = I8::try_from(1u8).unwrap(); - let mut res = one + I8::try_from(1u8).unwrap(); - assert(res == I8::try_from(2u8).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(11u8).unwrap(); - assert(res == I8::try_from(127u8).unwrap()); +#[test(should_revert)] +fn revert_signed_i8_add_unsafe_math() { + let _ = disable_panic_on_unsafe_math(); - res = I8::try_from(10u8).unwrap() * I8::try_from(127u8).unwrap(); - assert(res == I8::try_from(118u8).unwrap()); + let one = I8::try_from(1u8).unwrap(); + let max = I8::MAX; - res = I8::try_from(10u8).unwrap() * I8::try_from(10u8).unwrap(); - assert(res == I8::try_from(100u8).unwrap()); + let _ = max + one; +} - res = I8::try_from(10u8).unwrap() / I8::try_from(127u8).unwrap(); - assert(res == I8::try_from(118u8).unwrap()); +#[test] +fn signed_i8_add_overflow() { + let _ = disable_panic_on_overflow(); - res = I8::try_from(10u8).unwrap() / I8::try_from(5u8).unwrap(); - assert(res == I8::try_from(2u8).unwrap()); + let one = I8::try_from(1u8).unwrap(); + let max = I8::MAX; + + assert(max + one == I8::MIN); +} - // Subtraction Tests +#[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 +328,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 +624,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); + 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 = >::try_into(max); + 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 = >::try_into(zero); + assert(u8_min_try_into.is_some()); + assert(u8_min_try_into.unwrap() == u8::zero()); - // Test into u8 + let u8_overflow_try_into: Option = >::try_into(negative); + 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,43 +664,20 @@ 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); - - 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 u8_overflow_try_into: Option = negative.try_into(); - assert(u8_overflow_try_into.is_none()); - - // TotalOrd tests - 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); +#[test] +fn signed_i8_u8_try_into() { + let indent: u8 = I8::indent(); - 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); + 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); - 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); + 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()); - true + let i8_overflow_try_into: Option = >::try_into(indent); + assert(i8_overflow_try_into.is_none()); } 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 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 -} 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; - } -}