forked from cerc-io/stack-orchestrator
435 lines
15 KiB
Solidity
435 lines
15 KiB
Solidity
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
pragma solidity >=0.4.23;
|
|
|
|
contract DSTest {
|
|
event log (string);
|
|
event logs (bytes);
|
|
|
|
event log_address (address);
|
|
event log_bytes32 (bytes32);
|
|
event log_int (int);
|
|
event log_uint (uint);
|
|
event log_bytes (bytes);
|
|
event log_string (string);
|
|
|
|
event log_named_address (string key, address val);
|
|
event log_named_bytes32 (string key, bytes32 val);
|
|
event log_named_decimal_int (string key, int val, uint decimals);
|
|
event log_named_decimal_uint (string key, uint val, uint decimals);
|
|
event log_named_int (string key, int val);
|
|
event log_named_uint (string key, uint val);
|
|
event log_named_bytes (string key, bytes val);
|
|
event log_named_string (string key, string val);
|
|
|
|
bool public IS_TEST = true;
|
|
bool public failed;
|
|
|
|
address constant HEVM_ADDRESS =
|
|
address(bytes20(uint160(uint256(keccak256('hevm cheat code')))));
|
|
|
|
modifier mayRevert() { _; }
|
|
modifier testopts(string memory) { _; }
|
|
|
|
function fail() internal {
|
|
failed = true;
|
|
}
|
|
|
|
modifier logs_gas() {
|
|
uint startGas = gasleft();
|
|
_;
|
|
uint endGas = gasleft();
|
|
emit log_named_uint("gas", startGas - endGas);
|
|
}
|
|
|
|
function assertTrue(bool condition) internal {
|
|
if (!condition) {
|
|
emit log("Error: Assertion Failed");
|
|
fail();
|
|
}
|
|
}
|
|
|
|
function assertTrue(bool condition, string memory err) internal {
|
|
if (!condition) {
|
|
emit log_named_string("Error", err);
|
|
assertTrue(condition);
|
|
}
|
|
}
|
|
|
|
function assertEq(address a, address b) internal {
|
|
if (a != b) {
|
|
emit log("Error: a == b not satisfied [address]");
|
|
emit log_named_address(" Expected", b);
|
|
emit log_named_address(" Actual", a);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEq(address a, address b, string memory err) internal {
|
|
if (a != b) {
|
|
emit log_named_string ("Error", err);
|
|
assertEq(a, b);
|
|
}
|
|
}
|
|
|
|
function assertEq(bytes32 a, bytes32 b) internal {
|
|
if (a != b) {
|
|
emit log("Error: a == b not satisfied [bytes32]");
|
|
emit log_named_bytes32(" Expected", b);
|
|
emit log_named_bytes32(" Actual", a);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEq(bytes32 a, bytes32 b, string memory err) internal {
|
|
if (a != b) {
|
|
emit log_named_string ("Error", err);
|
|
assertEq(a, b);
|
|
}
|
|
}
|
|
function assertEq32(bytes32 a, bytes32 b) internal {
|
|
assertEq(a, b);
|
|
}
|
|
function assertEq32(bytes32 a, bytes32 b, string memory err) internal {
|
|
assertEq(a, b, err);
|
|
}
|
|
|
|
function assertEq(int a, int b) internal {
|
|
if (a != b) {
|
|
emit log("Error: a == b not satisfied [int]");
|
|
emit log_named_int(" Expected", b);
|
|
emit log_named_int(" Actual", a);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEq(int a, int b, string memory err) internal {
|
|
if (a != b) {
|
|
emit log_named_string("Error", err);
|
|
assertEq(a, b);
|
|
}
|
|
}
|
|
function assertEq(uint a, uint b) internal {
|
|
if (a != b) {
|
|
emit log("Error: a == b not satisfied [uint]");
|
|
emit log_named_uint(" Expected", b);
|
|
emit log_named_uint(" Actual", a);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEq(uint a, uint b, string memory err) internal {
|
|
if (a != b) {
|
|
emit log_named_string("Error", err);
|
|
assertEq(a, b);
|
|
}
|
|
}
|
|
function assertEqDecimal(int a, int b, uint decimals) internal {
|
|
if (a != b) {
|
|
emit log("Error: a == b not satisfied [decimal int]");
|
|
emit log_named_decimal_int(" Expected", b, decimals);
|
|
emit log_named_decimal_int(" Actual", a, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEqDecimal(int a, int b, uint decimals, string memory err) internal {
|
|
if (a != b) {
|
|
emit log_named_string("Error", err);
|
|
assertEqDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
function assertEqDecimal(uint a, uint b, uint decimals) internal {
|
|
if (a != b) {
|
|
emit log("Error: a == b not satisfied [decimal uint]");
|
|
emit log_named_decimal_uint(" Expected", b, decimals);
|
|
emit log_named_decimal_uint(" Actual", a, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEqDecimal(uint a, uint b, uint decimals, string memory err) internal {
|
|
if (a != b) {
|
|
emit log_named_string("Error", err);
|
|
assertEqDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
|
|
function assertGt(uint a, uint b) internal {
|
|
if (a <= b) {
|
|
emit log("Error: a > b not satisfied [uint]");
|
|
emit log_named_uint(" Value a", a);
|
|
emit log_named_uint(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGt(uint a, uint b, string memory err) internal {
|
|
if (a <= b) {
|
|
emit log_named_string("Error", err);
|
|
assertGt(a, b);
|
|
}
|
|
}
|
|
function assertGt(int a, int b) internal {
|
|
if (a <= b) {
|
|
emit log("Error: a > b not satisfied [int]");
|
|
emit log_named_int(" Value a", a);
|
|
emit log_named_int(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGt(int a, int b, string memory err) internal {
|
|
if (a <= b) {
|
|
emit log_named_string("Error", err);
|
|
assertGt(a, b);
|
|
}
|
|
}
|
|
function assertGtDecimal(int a, int b, uint decimals) internal {
|
|
if (a <= b) {
|
|
emit log("Error: a > b not satisfied [decimal int]");
|
|
emit log_named_decimal_int(" Value a", a, decimals);
|
|
emit log_named_decimal_int(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGtDecimal(int a, int b, uint decimals, string memory err) internal {
|
|
if (a <= b) {
|
|
emit log_named_string("Error", err);
|
|
assertGtDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
function assertGtDecimal(uint a, uint b, uint decimals) internal {
|
|
if (a <= b) {
|
|
emit log("Error: a > b not satisfied [decimal uint]");
|
|
emit log_named_decimal_uint(" Value a", a, decimals);
|
|
emit log_named_decimal_uint(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGtDecimal(uint a, uint b, uint decimals, string memory err) internal {
|
|
if (a <= b) {
|
|
emit log_named_string("Error", err);
|
|
assertGtDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
|
|
function assertGe(uint a, uint b) internal {
|
|
if (a < b) {
|
|
emit log("Error: a >= b not satisfied [uint]");
|
|
emit log_named_uint(" Value a", a);
|
|
emit log_named_uint(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGe(uint a, uint b, string memory err) internal {
|
|
if (a < b) {
|
|
emit log_named_string("Error", err);
|
|
assertGe(a, b);
|
|
}
|
|
}
|
|
function assertGe(int a, int b) internal {
|
|
if (a < b) {
|
|
emit log("Error: a >= b not satisfied [int]");
|
|
emit log_named_int(" Value a", a);
|
|
emit log_named_int(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGe(int a, int b, string memory err) internal {
|
|
if (a < b) {
|
|
emit log_named_string("Error", err);
|
|
assertGe(a, b);
|
|
}
|
|
}
|
|
function assertGeDecimal(int a, int b, uint decimals) internal {
|
|
if (a < b) {
|
|
emit log("Error: a >= b not satisfied [decimal int]");
|
|
emit log_named_decimal_int(" Value a", a, decimals);
|
|
emit log_named_decimal_int(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGeDecimal(int a, int b, uint decimals, string memory err) internal {
|
|
if (a < b) {
|
|
emit log_named_string("Error", err);
|
|
assertGeDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
function assertGeDecimal(uint a, uint b, uint decimals) internal {
|
|
if (a < b) {
|
|
emit log("Error: a >= b not satisfied [decimal uint]");
|
|
emit log_named_decimal_uint(" Value a", a, decimals);
|
|
emit log_named_decimal_uint(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertGeDecimal(uint a, uint b, uint decimals, string memory err) internal {
|
|
if (a < b) {
|
|
emit log_named_string("Error", err);
|
|
assertGeDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
|
|
function assertLt(uint a, uint b) internal {
|
|
if (a >= b) {
|
|
emit log("Error: a < b not satisfied [uint]");
|
|
emit log_named_uint(" Value a", a);
|
|
emit log_named_uint(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLt(uint a, uint b, string memory err) internal {
|
|
if (a >= b) {
|
|
emit log_named_string("Error", err);
|
|
assertLt(a, b);
|
|
}
|
|
}
|
|
function assertLt(int a, int b) internal {
|
|
if (a >= b) {
|
|
emit log("Error: a < b not satisfied [int]");
|
|
emit log_named_int(" Value a", a);
|
|
emit log_named_int(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLt(int a, int b, string memory err) internal {
|
|
if (a >= b) {
|
|
emit log_named_string("Error", err);
|
|
assertLt(a, b);
|
|
}
|
|
}
|
|
function assertLtDecimal(int a, int b, uint decimals) internal {
|
|
if (a >= b) {
|
|
emit log("Error: a < b not satisfied [decimal int]");
|
|
emit log_named_decimal_int(" Value a", a, decimals);
|
|
emit log_named_decimal_int(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLtDecimal(int a, int b, uint decimals, string memory err) internal {
|
|
if (a >= b) {
|
|
emit log_named_string("Error", err);
|
|
assertLtDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
function assertLtDecimal(uint a, uint b, uint decimals) internal {
|
|
if (a >= b) {
|
|
emit log("Error: a < b not satisfied [decimal uint]");
|
|
emit log_named_decimal_uint(" Value a", a, decimals);
|
|
emit log_named_decimal_uint(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLtDecimal(uint a, uint b, uint decimals, string memory err) internal {
|
|
if (a >= b) {
|
|
emit log_named_string("Error", err);
|
|
assertLtDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
|
|
function assertLe(uint a, uint b) internal {
|
|
if (a > b) {
|
|
emit log("Error: a <= b not satisfied [uint]");
|
|
emit log_named_uint(" Value a", a);
|
|
emit log_named_uint(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLe(uint a, uint b, string memory err) internal {
|
|
if (a > b) {
|
|
emit log_named_string("Error", err);
|
|
assertLe(a, b);
|
|
}
|
|
}
|
|
function assertLe(int a, int b) internal {
|
|
if (a > b) {
|
|
emit log("Error: a <= b not satisfied [int]");
|
|
emit log_named_int(" Value a", a);
|
|
emit log_named_int(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLe(int a, int b, string memory err) internal {
|
|
if (a > b) {
|
|
emit log_named_string("Error", err);
|
|
assertLe(a, b);
|
|
}
|
|
}
|
|
function assertLeDecimal(int a, int b, uint decimals) internal {
|
|
if (a > b) {
|
|
emit log("Error: a <= b not satisfied [decimal int]");
|
|
emit log_named_decimal_int(" Value a", a, decimals);
|
|
emit log_named_decimal_int(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLeDecimal(int a, int b, uint decimals, string memory err) internal {
|
|
if (a > b) {
|
|
emit log_named_string("Error", err);
|
|
assertLeDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
function assertLeDecimal(uint a, uint b, uint decimals) internal {
|
|
if (a > b) {
|
|
emit log("Error: a <= b not satisfied [decimal uint]");
|
|
emit log_named_decimal_uint(" Value a", a, decimals);
|
|
emit log_named_decimal_uint(" Value b", b, decimals);
|
|
fail();
|
|
}
|
|
}
|
|
function assertLeDecimal(uint a, uint b, uint decimals, string memory err) internal {
|
|
if (a > b) {
|
|
emit log_named_string("Error", err);
|
|
assertGeDecimal(a, b, decimals);
|
|
}
|
|
}
|
|
|
|
function assertEq(string memory a, string memory b) internal {
|
|
if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) {
|
|
emit log("Error: a == b not satisfied [string]");
|
|
emit log_named_string(" Value a", a);
|
|
emit log_named_string(" Value b", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEq(string memory a, string memory b, string memory err) internal {
|
|
if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) {
|
|
emit log_named_string("Error", err);
|
|
assertEq(a, b);
|
|
}
|
|
}
|
|
|
|
function checkEq0(bytes memory a, bytes memory b) internal pure returns (bool ok) {
|
|
ok = true;
|
|
if (a.length == b.length) {
|
|
for (uint i = 0; i < a.length; i++) {
|
|
if (a[i] != b[i]) {
|
|
ok = false;
|
|
}
|
|
}
|
|
} else {
|
|
ok = false;
|
|
}
|
|
}
|
|
function assertEq0(bytes memory a, bytes memory b) internal {
|
|
if (!checkEq0(a, b)) {
|
|
emit log("Error: a == b not satisfied [bytes]");
|
|
emit log_named_bytes(" Expected", a);
|
|
emit log_named_bytes(" Actual", b);
|
|
fail();
|
|
}
|
|
}
|
|
function assertEq0(bytes memory a, bytes memory b, string memory err) internal {
|
|
if (!checkEq0(a, b)) {
|
|
emit log_named_string("Error", err);
|
|
assertEq0(a, b);
|
|
}
|
|
}
|
|
}
|