poseidon-solidity-example/lib/forge-std/src/StdAssertions.sol
lib/forge-std/src/StdAssertions.solRaw
1// SPDX-License-Identifier: MIT
2pragma solidity >=0.6.2 <0.9.0;
3
4import {DSTest} from "ds-test/test.sol";
5import {stdMath} from "./StdMath.sol";
6
7abstract contract StdAssertions is DSTest {
8 event log_array(uint256[] val);
9 event log_array(int256[] val);
10 event log_array(address[] val);
11 event log_named_array(string key, uint256[] val);
12 event log_named_array(string key, int256[] val);
13 event log_named_array(string key, address[] val);
14
15 function fail(string memory err) internal virtual {
16 emit log_named_string("Error", err);
17 fail();
18 }
19
20 function assertFalse(bool data) internal virtual {
21 assertTrue(!data);
22 }
23
24 function assertFalse(bool data, string memory err) internal virtual {
25 assertTrue(!data, err);
26 }
27
28 function assertEq(bool a, bool b) internal virtual {
29 if (a != b) {
30 emit log("Error: a == b not satisfied [bool]");
31 emit log_named_string(" Expected", b ? "true" : "false");
32 emit log_named_string(" Actual", a ? "true" : "false");
33 fail();
34 }
35 }
36
37 function assertEq(bool a, bool b, string memory err) internal virtual {
38 if (a != b) {
39 emit log_named_string("Error", err);
40 assertEq(a, b);
41 }
42 }
43
44 function assertEq(bytes memory a, bytes memory b) internal virtual {
45 assertEq0(a, b);
46 }
47
48 function assertEq(bytes memory a, bytes memory b, string memory err) internal virtual {
49 assertEq0(a, b, err);
50 }
51
52 function assertEq(uint256[] memory a, uint256[] memory b) internal virtual {
53 if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
54 emit log("Error: a == b not satisfied [uint[]]");
55 emit log_named_array(" Expected", b);
56 emit log_named_array(" Actual", a);
57 fail();
58 }
59 }
60
61 function assertEq(int256[] memory a, int256[] memory b) internal virtual {
62 if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
63 emit log("Error: a == b not satisfied [int[]]");
64 emit log_named_array(" Expected", b);
65 emit log_named_array(" Actual", a);
66 fail();
67 }
68 }
69
70 function assertEq(address[] memory a, address[] memory b) internal virtual {
71 if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
72 emit log("Error: a == b not satisfied [address[]]");
73 emit log_named_array(" Expected", b);
74 emit log_named_array(" Actual", a);
75 fail();
76 }
77 }
78
79 function assertEq(uint256[] memory a, uint256[] memory b, string memory err) internal virtual {
80 if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
81 emit log_named_string("Error", err);
82 assertEq(a, b);
83 }
84 }
85
86 function assertEq(int256[] memory a, int256[] memory b, string memory err) internal virtual {
87 if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
88 emit log_named_string("Error", err);
89 assertEq(a, b);
90 }
91 }
92
93 function assertEq(address[] memory a, address[] memory b, string memory err) internal virtual {
94 if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
95 emit log_named_string("Error", err);
96 assertEq(a, b);
97 }
98 }
99
100 // Legacy helper
101 function assertEqUint(uint256 a, uint256 b) internal virtual {
102 assertEq(uint256(a), uint256(b));
103 }
104
105 function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta) internal virtual {
106 uint256 delta = stdMath.delta(a, b);
107
108 if (delta > maxDelta) {
109 emit log("Error: a ~= b not satisfied [uint]");
110 emit log_named_uint(" Expected", b);
111 emit log_named_uint(" Actual", a);
112 emit log_named_uint(" Max Delta", maxDelta);
113 emit log_named_uint(" Delta", delta);
114 fail();
115 }
116 }
117
118 function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta, string memory err) internal virtual {
119 uint256 delta = stdMath.delta(a, b);
120
121 if (delta > maxDelta) {
122 emit log_named_string("Error", err);
123 assertApproxEqAbs(a, b, maxDelta);
124 }
125 }
126
127 function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) internal virtual {
128 uint256 delta = stdMath.delta(a, b);
129
130 if (delta > maxDelta) {
131 emit log("Error: a ~= b not satisfied [uint]");
132 emit log_named_decimal_uint(" Expected", b, decimals);
133 emit log_named_decimal_uint(" Actual", a, decimals);
134 emit log_named_decimal_uint(" Max Delta", maxDelta, decimals);
135 emit log_named_decimal_uint(" Delta", delta, decimals);
136 fail();
137 }
138 }
139
140 function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals, string memory err)
141 internal
142 virtual
143 {
144 uint256 delta = stdMath.delta(a, b);
145
146 if (delta > maxDelta) {
147 emit log_named_string("Error", err);
148 assertApproxEqAbsDecimal(a, b, maxDelta, decimals);
149 }
150 }
151
152 function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta) internal virtual {
153 uint256 delta = stdMath.delta(a, b);
154
155 if (delta > maxDelta) {
156 emit log("Error: a ~= b not satisfied [int]");
157 emit log_named_int(" Expected", b);
158 emit log_named_int(" Actual", a);
159 emit log_named_uint(" Max Delta", maxDelta);
160 emit log_named_uint(" Delta", delta);
161 fail();
162 }
163 }
164
165 function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta, string memory err) internal virtual {
166 uint256 delta = stdMath.delta(a, b);
167
168 if (delta > maxDelta) {
169 emit log_named_string("Error", err);
170 assertApproxEqAbs(a, b, maxDelta);
171 }
172 }
173
174 function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals) internal virtual {
175 uint256 delta = stdMath.delta(a, b);
176
177 if (delta > maxDelta) {
178 emit log("Error: a ~= b not satisfied [int]");
179 emit log_named_decimal_int(" Expected", b, decimals);
180 emit log_named_decimal_int(" Actual", a, decimals);
181 emit log_named_decimal_uint(" Max Delta", maxDelta, decimals);
182 emit log_named_decimal_uint(" Delta", delta, decimals);
183 fail();
184 }
185 }
186
187 function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals, string memory err)
188 internal
189 virtual
190 {
191 uint256 delta = stdMath.delta(a, b);
192
193 if (delta > maxDelta) {
194 emit log_named_string("Error", err);
195 assertApproxEqAbsDecimal(a, b, maxDelta, decimals);
196 }
197 }
198
199 function assertApproxEqRel(
200 uint256 a,
201 uint256 b,
202 uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
203 ) internal virtual {
204 if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too.
205
206 uint256 percentDelta = stdMath.percentDelta(a, b);
207
208 if (percentDelta > maxPercentDelta) {
209 emit log("Error: a ~= b not satisfied [uint]");
210 emit log_named_uint(" Expected", b);
211 emit log_named_uint(" Actual", a);
212 emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
213 emit log_named_decimal_uint(" % Delta", percentDelta, 18);
214 fail();
215 }
216 }
217
218 function assertApproxEqRel(
219 uint256 a,
220 uint256 b,
221 uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
222 string memory err
223 ) internal virtual {
224 if (b == 0) return assertEq(a, b, err); // If the expected is 0, actual must be too.
225
226 uint256 percentDelta = stdMath.percentDelta(a, b);
227
228 if (percentDelta > maxPercentDelta) {
229 emit log_named_string("Error", err);
230 assertApproxEqRel(a, b, maxPercentDelta);
231 }
232 }
233
234 function assertApproxEqRelDecimal(
235 uint256 a,
236 uint256 b,
237 uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
238 uint256 decimals
239 ) internal virtual {
240 if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too.
241
242 uint256 percentDelta = stdMath.percentDelta(a, b);
243
244 if (percentDelta > maxPercentDelta) {
245 emit log("Error: a ~= b not satisfied [uint]");
246 emit log_named_decimal_uint(" Expected", b, decimals);
247 emit log_named_decimal_uint(" Actual", a, decimals);
248 emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
249 emit log_named_decimal_uint(" % Delta", percentDelta, 18);
250 fail();
251 }
252 }
253
254 function assertApproxEqRelDecimal(
255 uint256 a,
256 uint256 b,
257 uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
258 uint256 decimals,
259 string memory err
260 ) internal virtual {
261 if (b == 0) return assertEq(a, b, err); // If the expected is 0, actual must be too.
262
263 uint256 percentDelta = stdMath.percentDelta(a, b);
264
265 if (percentDelta > maxPercentDelta) {
266 emit log_named_string("Error", err);
267 assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals);
268 }
269 }
270
271 function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta) internal virtual {
272 if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too.
273
274 uint256 percentDelta = stdMath.percentDelta(a, b);
275
276 if (percentDelta > maxPercentDelta) {
277 emit log("Error: a ~= b not satisfied [int]");
278 emit log_named_int(" Expected", b);
279 emit log_named_int(" Actual", a);
280 emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
281 emit log_named_decimal_uint(" % Delta", percentDelta, 18);
282 fail();
283 }
284 }
285
286 function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta, string memory err) internal virtual {
287 if (b == 0) return assertEq(a, b, err); // If the expected is 0, actual must be too.
288
289 uint256 percentDelta = stdMath.percentDelta(a, b);
290
291 if (percentDelta > maxPercentDelta) {
292 emit log_named_string("Error", err);
293 assertApproxEqRel(a, b, maxPercentDelta);
294 }
295 }
296
297 function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals) internal virtual {
298 if (b == 0) return assertEq(a, b); // If the expected is 0, actual must be too.
299
300 uint256 percentDelta = stdMath.percentDelta(a, b);
301
302 if (percentDelta > maxPercentDelta) {
303 emit log("Error: a ~= b not satisfied [int]");
304 emit log_named_decimal_int(" Expected", b, decimals);
305 emit log_named_decimal_int(" Actual", a, decimals);
306 emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
307 emit log_named_decimal_uint(" % Delta", percentDelta, 18);
308 fail();
309 }
310 }
311
312 function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals, string memory err)
313 internal
314 virtual
315 {
316 if (b == 0) return assertEq(a, b, err); // If the expected is 0, actual must be too.
317
318 uint256 percentDelta = stdMath.percentDelta(a, b);
319
320 if (percentDelta > maxPercentDelta) {
321 emit log_named_string("Error", err);
322 assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals);
323 }
324 }
325}