diff --git a/src/Uint128/BaseQuantoPerUSDUint128/Casting.sol b/src/Uint128/BaseQuantoPerUSDUint128/Casting.sol index c9a6019..346abbc 100644 --- a/src/Uint128/BaseQuantoPerUSDUint128/Casting.sol +++ b/src/Uint128/BaseQuantoPerUSDUint128/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint128 x) pure returns (BaseQuantoPerUSDUint128 result) { function unwrap(BaseQuantoPerUSDUint128 x) pure returns (uint128 result) { result = BaseQuantoPerUSDUint128.unwrap(x); } - -/// @notice Converts a BaseQuantoPerUSDUint128 number into bytes32. -function toBytes32(BaseQuantoPerUSDUint128 x) pure returns (bytes32 result) { - result = bytes32(uint256(unwrap(x))); -} diff --git a/src/Uint128/BaseQuantoPerUSDUint128/ValueType.sol b/src/Uint128/BaseQuantoPerUSDUint128/ValueType.sol index 238f870..57730f3 100644 --- a/src/Uint128/BaseQuantoPerUSDUint128/ValueType.sol +++ b/src/Uint128/BaseQuantoPerUSDUint128/ValueType.sol @@ -11,8 +11,7 @@ type BaseQuantoPerUSDUint128 is uint128; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for BaseQuantoPerUSDUint128 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint128/BaseUint128/Casting.sol b/src/Uint128/BaseUint128/Casting.sol index 4563c7e..c8a149c 100644 --- a/src/Uint128/BaseUint128/Casting.sol +++ b/src/Uint128/BaseUint128/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint128 x) pure returns (BaseUint128 result) { function unwrap(BaseUint128 x) pure returns (uint128 result) { result = BaseUint128.unwrap(x); } - -/// @notice Converts a BaseUint128 number into bytes32. -function toBytes32(BaseUint128 x) pure returns (bytes32 result) { - result = bytes32(uint256(unwrap(x))); -} diff --git a/src/Uint128/BaseUint128/ValueType.sol b/src/Uint128/BaseUint128/ValueType.sol index 1f1a824..6a057c8 100644 --- a/src/Uint128/BaseUint128/ValueType.sol +++ b/src/Uint128/BaseUint128/ValueType.sol @@ -11,7 +11,7 @@ type BaseUint128 is uint128; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, Casting.toBytes32 + Casting.unwrap } for BaseUint128 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint128/QuantoUint128/Casting.sol b/src/Uint128/QuantoUint128/Casting.sol index 66a8b10..3a594d7 100644 --- a/src/Uint128/QuantoUint128/Casting.sol +++ b/src/Uint128/QuantoUint128/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint128 x) pure returns (QuantoUint128 result) { function unwrap(QuantoUint128 x) pure returns (uint128 result) { result = QuantoUint128.unwrap(x); } - -/// @notice Converts a QuantoUint128 number into bytes32. -function toBytes32(QuantoUint128 x) pure returns (bytes32 result) { - result = bytes32(uint256(unwrap(x))); -} diff --git a/src/Uint128/QuantoUint128/ValueType.sol b/src/Uint128/QuantoUint128/ValueType.sol index ffb9487..6cee0d9 100644 --- a/src/Uint128/QuantoUint128/ValueType.sol +++ b/src/Uint128/QuantoUint128/ValueType.sol @@ -11,8 +11,7 @@ type QuantoUint128 is uint128; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for QuantoUint128 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint128/USDPerBaseUint128/Casting.sol b/src/Uint128/USDPerBaseUint128/Casting.sol index 4956dc0..a3c356f 100644 --- a/src/Uint128/USDPerBaseUint128/Casting.sol +++ b/src/Uint128/USDPerBaseUint128/Casting.sol @@ -13,8 +13,3 @@ function wrap(uint128 x) pure returns (USDPerBaseUint128 result) { function unwrap(USDPerBaseUint128 x) pure returns (uint128 result) { result = USDPerBaseUint128.unwrap(x); } - -/// @notice Converts a USDPerBaseUint128 number into bytes32. -function toBytes32(USDPerBaseUint128 x) pure returns (bytes32 result) { - result = bytes32(uint256(unwrap(x))); -} diff --git a/src/Uint128/USDPerBaseUint128/ValueType.sol b/src/Uint128/USDPerBaseUint128/ValueType.sol index 3431987..bfb35dd 100644 --- a/src/Uint128/USDPerBaseUint128/ValueType.sol +++ b/src/Uint128/USDPerBaseUint128/ValueType.sol @@ -11,8 +11,7 @@ type USDPerBaseUint128 is uint128; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for USDPerBaseUint128 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint128/USDPerQuantoUint128/Casting.sol b/src/Uint128/USDPerQuantoUint128/Casting.sol index a8917bd..648d6ed 100644 --- a/src/Uint128/USDPerQuantoUint128/Casting.sol +++ b/src/Uint128/USDPerQuantoUint128/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint128 x) pure returns (USDPerQuantoUint128 result) { function unwrap(USDPerQuantoUint128 x) pure returns (uint128 result) { result = USDPerQuantoUint128.unwrap(x); } - -/// @notice Converts a USDPerQuantoUint128 number into bytes32. -function toBytes32(USDPerQuantoUint128 x) pure returns (bytes32 result) { - result = bytes32(uint256(unwrap(x))); -} diff --git a/src/Uint128/USDPerQuantoUint128/ValueType.sol b/src/Uint128/USDPerQuantoUint128/ValueType.sol index 7ee6f0c..b87189a 100644 --- a/src/Uint128/USDPerQuantoUint128/ValueType.sol +++ b/src/Uint128/USDPerQuantoUint128/ValueType.sol @@ -11,8 +11,7 @@ type USDPerQuantoUint128 is uint128; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for USDPerQuantoUint128 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint128/USDUint128/Casting.sol b/src/Uint128/USDUint128/Casting.sol index 8cfbacc..1f9c18f 100644 --- a/src/Uint128/USDUint128/Casting.sol +++ b/src/Uint128/USDUint128/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint128 x) pure returns (USDUint128 result) { function unwrap(USDUint128 x) pure returns (uint128 result) { result = USDUint128.unwrap(x); } - -/// @notice Converts a USDUint128 number into bytes32. -function toBytes32(USDUint128 x) pure returns (bytes32 result) { - result = bytes32(uint256(unwrap(x))); -} diff --git a/src/Uint128/USDUint128/ValueType.sol b/src/Uint128/USDUint128/ValueType.sol index 78444ac..bc0cb8d 100644 --- a/src/Uint128/USDUint128/ValueType.sol +++ b/src/Uint128/USDUint128/ValueType.sol @@ -11,7 +11,7 @@ type USDUint128 is uint128; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, Casting.toBytes32 + Casting.unwrap } for USDUint128 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint256/BaseQuantoPerUSDUint256/Casting.sol b/src/Uint256/BaseQuantoPerUSDUint256/Casting.sol index 6dc4312..3665ed9 100644 --- a/src/Uint256/BaseQuantoPerUSDUint256/Casting.sol +++ b/src/Uint256/BaseQuantoPerUSDUint256/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint256 x) pure returns (BaseQuantoPerUSDUint256 result) { function unwrap(BaseQuantoPerUSDUint256 x) pure returns (uint256 result) { result = BaseQuantoPerUSDUint256.unwrap(x); } - -/// @notice Converts a BaseQuantoPerUSDUint256 number into bytes32. -function toBytes32(BaseQuantoPerUSDUint256 x) pure returns (bytes32 result) { - result = bytes32(unwrap(x)); -} diff --git a/src/Uint256/BaseQuantoPerUSDUint256/ValueType.sol b/src/Uint256/BaseQuantoPerUSDUint256/ValueType.sol index c101f6b..abc4b06 100644 --- a/src/Uint256/BaseQuantoPerUSDUint256/ValueType.sol +++ b/src/Uint256/BaseQuantoPerUSDUint256/ValueType.sol @@ -11,8 +11,7 @@ type BaseQuantoPerUSDUint256 is uint256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for BaseQuantoPerUSDUint256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint256/BaseUint256/Casting.sol b/src/Uint256/BaseUint256/Casting.sol index b8c6f3a..ee96991 100644 --- a/src/Uint256/BaseUint256/Casting.sol +++ b/src/Uint256/BaseUint256/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint256 x) pure returns (BaseUint256 result) { function unwrap(BaseUint256 x) pure returns (uint256 result) { result = BaseUint256.unwrap(x); } - -/// @notice Converts a BaseUint256 number into bytes32. -function toBytes32(BaseUint256 x) pure returns (bytes32 result) { - result = bytes32(unwrap(x)); -} diff --git a/src/Uint256/BaseUint256/ValueType.sol b/src/Uint256/BaseUint256/ValueType.sol index 2ed1e28..41c7cab 100644 --- a/src/Uint256/BaseUint256/ValueType.sol +++ b/src/Uint256/BaseUint256/ValueType.sol @@ -11,8 +11,7 @@ type BaseUint256 is uint256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for BaseUint256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint256/QuantoUint256/Casting.sol b/src/Uint256/QuantoUint256/Casting.sol index c920063..58ecffb 100644 --- a/src/Uint256/QuantoUint256/Casting.sol +++ b/src/Uint256/QuantoUint256/Casting.sol @@ -12,9 +12,3 @@ function wrap(uint256 x) pure returns (QuantoUint256 result) { function unwrap(QuantoUint256 x) pure returns (uint256 result) { result = QuantoUint256.unwrap(x); } - - -/// @notice Converts a QuantoUint256 number into bytes32. -function toBytes32(QuantoUint256 x) pure returns (bytes32 result) { - result = bytes32(unwrap(x)); -} diff --git a/src/Uint256/QuantoUint256/ValueType.sol b/src/Uint256/QuantoUint256/ValueType.sol index d1e678d..cff8c87 100644 --- a/src/Uint256/QuantoUint256/ValueType.sol +++ b/src/Uint256/QuantoUint256/ValueType.sol @@ -11,8 +11,7 @@ type QuantoUint256 is uint256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for QuantoUint256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint256/USDPerBaseUint256/Casting.sol b/src/Uint256/USDPerBaseUint256/Casting.sol index 3e09f4f..1086f6b 100644 --- a/src/Uint256/USDPerBaseUint256/Casting.sol +++ b/src/Uint256/USDPerBaseUint256/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint256 x) pure returns (USDPerBaseUint256 result) { function unwrap(USDPerBaseUint256 x) pure returns (uint256 result) { result = USDPerBaseUint256.unwrap(x); } - -/// @notice Converts a USDPerBaseUint256 number into bytes32. -function toBytes32(USDPerBaseUint256 x) pure returns (bytes32 result) { - result = bytes32(unwrap(x)); -} diff --git a/src/Uint256/USDPerBaseUint256/ValueType.sol b/src/Uint256/USDPerBaseUint256/ValueType.sol index ae13f6f..0a6a71b 100644 --- a/src/Uint256/USDPerBaseUint256/ValueType.sol +++ b/src/Uint256/USDPerBaseUint256/ValueType.sol @@ -11,8 +11,7 @@ type USDPerBaseUint256 is uint256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for USDPerBaseUint256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint256/USDPerQuantoUint256/Casting.sol b/src/Uint256/USDPerQuantoUint256/Casting.sol index 6caad63..18a1060 100644 --- a/src/Uint256/USDPerQuantoUint256/Casting.sol +++ b/src/Uint256/USDPerQuantoUint256/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint256 x) pure returns (USDPerQuantoUint256 result) { function unwrap(USDPerQuantoUint256 x) pure returns (uint256 result) { result = USDPerQuantoUint256.unwrap(x); } - -/// @notice Converts a USDPerQuantoUint256 number into bytes32. -function toBytes32(USDPerQuantoUint256 x) pure returns (bytes32 result) { - result = bytes32(unwrap(x)); -} diff --git a/src/Uint256/USDPerQuantoUint256/ValueType.sol b/src/Uint256/USDPerQuantoUint256/ValueType.sol index 3aee0ad..9594cd7 100644 --- a/src/Uint256/USDPerQuantoUint256/ValueType.sol +++ b/src/Uint256/USDPerQuantoUint256/ValueType.sol @@ -11,8 +11,7 @@ type USDPerQuantoUint256 is uint256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for USDPerQuantoUint256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Uint256/USDUint256/Casting.sol b/src/Uint256/USDUint256/Casting.sol index ea49753..7371a6c 100644 --- a/src/Uint256/USDUint256/Casting.sol +++ b/src/Uint256/USDUint256/Casting.sol @@ -12,8 +12,3 @@ function wrap(uint256 x) pure returns (USDUint256 result) { function unwrap(USDUint256 x) pure returns (uint256 result) { result = USDUint256.unwrap(x); } - -/// @notice Converts a USDUint256 number into bytes32. -function toBytes32(USDUint256 x) pure returns (bytes32 result) { - result = bytes32(unwrap(x)); -} diff --git a/src/Uint256/USDUint256/ValueType.sol b/src/Uint256/USDUint256/ValueType.sol index 6982690..6c329e3 100644 --- a/src/Uint256/USDUint256/ValueType.sol +++ b/src/Uint256/USDUint256/ValueType.sol @@ -11,8 +11,7 @@ type USDUint256 is uint256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, - Casting.toBytes32 + Casting.unwrap } for USDUint256 global; /*////////////////////////////////////////////////////////////// diff --git a/test/Uint128/BaseQuantoPerUSDUint128.t.sol b/test/Uint128/BaseQuantoPerUSDUint128.t.sol index b200fad..3a7f638 100644 --- a/test/Uint128/BaseQuantoPerUSDUint128.t.sol +++ b/test/Uint128/BaseQuantoPerUSDUint128.t.sol @@ -402,15 +402,4 @@ contract BaseQuantoPerUSDUint128Test is Test { assertEq(result.unwrap(), z); } } - - function testBaseQuantoPerUSDUint128ToBytes32() public { - uint128 x = type(uint128).max; - bytes32 result = BaseQuantoPerUSDUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } - - function testBaseQuantoPerUSDUint128ToBytes32Fuzz(uint128 x) public { - bytes32 result = BaseQuantoPerUSDUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } } diff --git a/test/Uint128/BaseUint128.t.sol b/test/Uint128/BaseUint128.t.sol index 2a94b85..da54548 100644 --- a/test/Uint128/BaseUint128.t.sol +++ b/test/Uint128/BaseUint128.t.sol @@ -347,15 +347,4 @@ contract BaseUint128Test is Test { assertEq(result.unwrap(), z); } } - - function testBaseUint128ToBytes32() public { - uint128 x = type(uint128).max; - bytes32 result = BaseUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } - - function testBaseUint128ToBytes32Fuzz(uint128 x) public { - bytes32 result = BaseUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } } diff --git a/test/Uint128/QuantoUint128.t.sol b/test/Uint128/QuantoUint128.t.sol index 73c2030..54377d7 100644 --- a/test/Uint128/QuantoUint128.t.sol +++ b/test/Uint128/QuantoUint128.t.sol @@ -348,15 +348,4 @@ contract QuantoUint128Test is Test { assertEq(result.unwrap(), z); } } - - function testQuantoUint128ToBytes32() public { - uint128 x = type(uint128).max; - bytes32 result = QuantoUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } - - function testQuantoUint128ToBytes32Fuzz(uint128 x) public { - bytes32 result = QuantoUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } } diff --git a/test/Uint128/USDPerBaseUint128.t.sol b/test/Uint128/USDPerBaseUint128.t.sol index 84e405a..6092360 100644 --- a/test/Uint128/USDPerBaseUint128.t.sol +++ b/test/Uint128/USDPerBaseUint128.t.sol @@ -387,15 +387,4 @@ contract USDPerBaseUint128Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDPerBaseUint128ToBytes32() public { - uint128 x = type(uint128).max; - bytes32 result = USDPerBaseUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } - - function testUSDPerBaseUint128ToBytes32Fuzz(uint128 x) public { - bytes32 result = USDPerBaseUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } } diff --git a/test/Uint128/USDPerQuantoUint128.t.sol b/test/Uint128/USDPerQuantoUint128.t.sol index 2838421..37e2156 100644 --- a/test/Uint128/USDPerQuantoUint128.t.sol +++ b/test/Uint128/USDPerQuantoUint128.t.sol @@ -391,15 +391,4 @@ contract USDPerQuantoUint128Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDPerQuantoUint128ToBytes32() public { - uint128 x = type(uint128).max; - bytes32 result = USDPerQuantoUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } - - function testUSDPerQuantoUint128ToBytes32Fuzz(uint128 x) public { - bytes32 result = USDPerQuantoUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } } diff --git a/test/Uint128/USDUint128.t.sol b/test/Uint128/USDUint128.t.sol index 60f98c4..7975a79 100644 --- a/test/Uint128/USDUint128.t.sol +++ b/test/Uint128/USDUint128.t.sol @@ -315,15 +315,4 @@ contract USDUint128Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDUint128ToBytes32() public { - uint128 x = type(uint128).max; - bytes32 result = USDUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } - - function testUSDUint128ToBytes32Fuzz(uint128 x) public { - bytes32 result = USDUint128.wrap(x).toBytes32(); - assertEq(result, bytes32(uint256(x))); - } } diff --git a/test/Uint256/BaseQuantoPerUSDUint256.t.sol b/test/Uint256/BaseQuantoPerUSDUint256.t.sol index 3cf7020..cef1912 100644 --- a/test/Uint256/BaseQuantoPerUSDUint256.t.sol +++ b/test/Uint256/BaseQuantoPerUSDUint256.t.sol @@ -402,15 +402,4 @@ contract BaseQuantoPerUSDUint256Test is Test { assertEq(result.unwrap(), z); } } - - function testBaseQuantoPerUSDUint256ToBytes32() public { - uint256 x = type(uint256).max; - bytes32 result = BaseQuantoPerUSDUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } - - function testBaseQuantoPerUSDUint256ToBytes32Fuzz(uint256 x) public { - bytes32 result = BaseQuantoPerUSDUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } } diff --git a/test/Uint256/BaseUint256.t.sol b/test/Uint256/BaseUint256.t.sol index c8c2fe7..f3dd417 100644 --- a/test/Uint256/BaseUint256.t.sol +++ b/test/Uint256/BaseUint256.t.sol @@ -347,15 +347,4 @@ contract BaseUint256Test is Test { assertEq(result.unwrap(), z); } } - - function testBaseUint256ToBytes32() public { - uint256 x = type(uint256).max; - bytes32 result = BaseUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } - - function testBaseUint256ToBytes32Fuzz(uint256 x) public { - bytes32 result = BaseUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } } diff --git a/test/Uint256/QuantoUint256.t.sol b/test/Uint256/QuantoUint256.t.sol index df44d74..d2b883b 100644 --- a/test/Uint256/QuantoUint256.t.sol +++ b/test/Uint256/QuantoUint256.t.sol @@ -348,15 +348,4 @@ contract QuantoUint256Test is Test { assertEq(result.unwrap(), z); } } - - function testQuantoUint256ToBytes32() public { - uint256 x = type(uint256).max; - bytes32 result = QuantoUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } - - function testQuantoUint256ToBytes32Fuzz(uint256 x) public { - bytes32 result = QuantoUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } } diff --git a/test/Uint256/USDPerBaseUint256.t.sol b/test/Uint256/USDPerBaseUint256.t.sol index da00b24..bf67012 100644 --- a/test/Uint256/USDPerBaseUint256.t.sol +++ b/test/Uint256/USDPerBaseUint256.t.sol @@ -387,15 +387,4 @@ contract USDPerBaseUint256Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDPerBaseUint256ToBytes32() public { - uint256 x = type(uint256).max; - bytes32 result = USDPerBaseUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } - - function testUSDPerBaseUint256ToBytes32Fuzz(uint256 x) public { - bytes32 result = USDPerBaseUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } } diff --git a/test/Uint256/USDPerQuantoUint256.t.sol b/test/Uint256/USDPerQuantoUint256.t.sol index ca9c899..b53a7e9 100644 --- a/test/Uint256/USDPerQuantoUint256.t.sol +++ b/test/Uint256/USDPerQuantoUint256.t.sol @@ -391,15 +391,4 @@ contract USDPerQuantoUint256Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDPerQuantoUint256ToBytes32() public { - uint256 x = type(uint256).max; - bytes32 result = USDPerQuantoUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } - - function testUSDPerQuantoUint256ToBytes32Fuzz(uint256 x) public { - bytes32 result = USDPerQuantoUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } } diff --git a/test/Uint256/USDUint256.t.sol b/test/Uint256/USDUint256.t.sol index 6b428e6..1ac31aa 100644 --- a/test/Uint256/USDUint256.t.sol +++ b/test/Uint256/USDUint256.t.sol @@ -315,15 +315,4 @@ contract USDUint256Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDUint256ToBytes32() public { - uint256 x = type(uint256).max; - bytes32 result = USDUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } - - function testUSDUint256ToBytes32Fuzz(uint256 x) public { - bytes32 result = USDUint256.wrap(x).toBytes32(); - assertEq(result, bytes32(x)); - } }