Skip to content

Commit f11f816

Browse files
hodlinatorhodlinator
committed
refactor: Make uint256_tests no longer use deprecated BOOST_CHECK()
1 parent f0eeee2 commit f11f816

File tree

3 files changed

+150
-136
lines changed

3 files changed

+150
-136
lines changed

‎src/test/uint256_tests.cpp

Lines changed: 134 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -73,54 +73,53 @@ inline uint160 uint160S(const std::string& str)
7373

7474
BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
7575
{
76-
BOOST_CHECK(1 == 0+1);
7776
// constructor uint256(vector<char>):
78-
BOOST_CHECK(R1L.ToString() == ArrayToString(R1Array,32));
79-
BOOST_CHECK(R1S.ToString() == ArrayToString(R1Array,20));
80-
BOOST_CHECK(R2L.ToString() == ArrayToString(R2Array,32));
81-
BOOST_CHECK(R2S.ToString() == ArrayToString(R2Array,20));
82-
BOOST_CHECK(ZeroL.ToString() == ArrayToString(ZeroArray,32));
83-
BOOST_CHECK(ZeroS.ToString() == ArrayToString(ZeroArray,20));
84-
BOOST_CHECK(OneL.ToString() == ArrayToString(OneArray,32));
85-
BOOST_CHECK(OneS.ToString() == ArrayToString(OneArray,20));
86-
BOOST_CHECK(MaxL.ToString() == ArrayToString(MaxArray,32));
87-
BOOST_CHECK(MaxS.ToString() == ArrayToString(MaxArray,20));
88-
BOOST_CHECK(OneL.ToString() != ArrayToString(ZeroArray,32));
89-
BOOST_CHECK(OneS.ToString() != ArrayToString(ZeroArray,20));
77+
BOOST_CHECK_EQUAL(R1L.ToString(), ArrayToString(R1Array,32));
78+
BOOST_CHECK_EQUAL(R1S.ToString(), ArrayToString(R1Array,20));
79+
BOOST_CHECK_EQUAL(R2L.ToString(), ArrayToString(R2Array,32));
80+
BOOST_CHECK_EQUAL(R2S.ToString(), ArrayToString(R2Array,20));
81+
BOOST_CHECK_EQUAL(ZeroL.ToString(), ArrayToString(ZeroArray,32));
82+
BOOST_CHECK_EQUAL(ZeroS.ToString(), ArrayToString(ZeroArray,20));
83+
BOOST_CHECK_EQUAL(OneL.ToString(), ArrayToString(OneArray,32));
84+
BOOST_CHECK_EQUAL(OneS.ToString(), ArrayToString(OneArray,20));
85+
BOOST_CHECK_EQUAL(MaxL.ToString(), ArrayToString(MaxArray,32));
86+
BOOST_CHECK_EQUAL(MaxS.ToString(), ArrayToString(MaxArray,20));
87+
BOOST_CHECK_NE(OneL.ToString(), ArrayToString(ZeroArray,32));
88+
BOOST_CHECK_NE(OneS.ToString(), ArrayToString(ZeroArray,20));
9089

9190
// == and !=
92-
BOOST_CHECK(R1L != R2L && R1S != R2S);
93-
BOOST_CHECK(ZeroL != OneL && ZeroS != OneS);
94-
BOOST_CHECK(OneL != ZeroL && OneS != ZeroS);
95-
BOOST_CHECK(MaxL != ZeroL && MaxS != ZeroS);
91+
BOOST_CHECK_NE(R1L, R2L); BOOST_CHECK_NE(R1S, R2S);
92+
BOOST_CHECK_NE(ZeroL, OneL); BOOST_CHECK_NE(ZeroS, OneS);
93+
BOOST_CHECK_NE(OneL, ZeroL); BOOST_CHECK_NE(OneS, ZeroS);
94+
BOOST_CHECK_NE(MaxL, ZeroL); BOOST_CHECK_NE(MaxS, ZeroS);
9695

9796
// String Constructor and Copy Constructor
98-
BOOST_CHECK(uint256S("0x"+R1L.ToString()) == R1L);
99-
BOOST_CHECK(uint256S("0x"+R2L.ToString()) == R2L);
100-
BOOST_CHECK(uint256S("0x"+ZeroL.ToString()) == ZeroL);
101-
BOOST_CHECK(uint256S("0x"+OneL.ToString()) == OneL);
102-
BOOST_CHECK(uint256S("0x"+MaxL.ToString()) == MaxL);
103-
BOOST_CHECK(uint256S(R1L.ToString()) == R1L);
104-
BOOST_CHECK(uint256S(" 0x"+R1L.ToString()+" ") == R1L);
105-
BOOST_CHECK(uint256S("") == ZeroL);
106-
BOOST_CHECK(R1L == uint256S(R1ArrayHex));
107-
BOOST_CHECK(uint256(R1L) == R1L);
108-
BOOST_CHECK(uint256(ZeroL) == ZeroL);
109-
BOOST_CHECK(uint256(OneL) == OneL);
110-
111-
BOOST_CHECK(uint160S("0x"+R1S.ToString()) == R1S);
112-
BOOST_CHECK(uint160S("0x"+R2S.ToString()) == R2S);
113-
BOOST_CHECK(uint160S("0x"+ZeroS.ToString()) == ZeroS);
114-
BOOST_CHECK(uint160S("0x"+OneS.ToString()) == OneS);
115-
BOOST_CHECK(uint160S("0x"+MaxS.ToString()) == MaxS);
116-
BOOST_CHECK(uint160S(R1S.ToString()) == R1S);
117-
BOOST_CHECK(uint160S(" 0x"+R1S.ToString()+" ") == R1S);
118-
BOOST_CHECK(uint160S("") == ZeroS);
119-
BOOST_CHECK(R1S == uint160S(R1ArrayHex));
120-
121-
BOOST_CHECK(uint160(R1S) == R1S);
122-
BOOST_CHECK(uint160(ZeroS) == ZeroS);
123-
BOOST_CHECK(uint160(OneS) == OneS);
97+
BOOST_CHECK_EQUAL(uint256S("0x"+R1L.ToString()), R1L);
98+
BOOST_CHECK_EQUAL(uint256S("0x"+R2L.ToString()), R2L);
99+
BOOST_CHECK_EQUAL(uint256S("0x"+ZeroL.ToString()), ZeroL);
100+
BOOST_CHECK_EQUAL(uint256S("0x"+OneL.ToString()), OneL);
101+
BOOST_CHECK_EQUAL(uint256S("0x"+MaxL.ToString()), MaxL);
102+
BOOST_CHECK_EQUAL(uint256S(R1L.ToString()), R1L);
103+
BOOST_CHECK_EQUAL(uint256S(" 0x"+R1L.ToString()+" "), R1L);
104+
BOOST_CHECK_EQUAL(uint256S(""), ZeroL);
105+
BOOST_CHECK_EQUAL(R1L, uint256S(R1ArrayHex));
106+
BOOST_CHECK_EQUAL(uint256(R1L), R1L);
107+
BOOST_CHECK_EQUAL(uint256(ZeroL), ZeroL);
108+
BOOST_CHECK_EQUAL(uint256(OneL), OneL);
109+
110+
BOOST_CHECK_EQUAL(uint160S("0x"+R1S.ToString()), R1S);
111+
BOOST_CHECK_EQUAL(uint160S("0x"+R2S.ToString()), R2S);
112+
BOOST_CHECK_EQUAL(uint160S("0x"+ZeroS.ToString()), ZeroS);
113+
BOOST_CHECK_EQUAL(uint160S("0x"+OneS.ToString()), OneS);
114+
BOOST_CHECK_EQUAL(uint160S("0x"+MaxS.ToString()), MaxS);
115+
BOOST_CHECK_EQUAL(uint160S(R1S.ToString()), R1S);
116+
BOOST_CHECK_EQUAL(uint160S(" 0x"+R1S.ToString()+" "), R1S);
117+
BOOST_CHECK_EQUAL(uint160S(""), ZeroS);
118+
BOOST_CHECK_EQUAL(R1S, uint160S(R1ArrayHex));
119+
120+
BOOST_CHECK_EQUAL(uint160(R1S), R1S);
121+
BOOST_CHECK_EQUAL(uint160(ZeroS), ZeroS);
122+
BOOST_CHECK_EQUAL(uint160(OneS), OneS);
124123
}
125124

126125
BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
@@ -129,140 +128,140 @@ BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
129128
for (int i = 255; i >= 0; --i) {
130129
uint256 TmpL;
131130
*(TmpL.begin() + (i>>3)) |= 1<<(7-(i&7));
132-
BOOST_CHECK( LastL < TmpL );
131+
BOOST_CHECK_LT(LastL, TmpL);
133132
LastL = TmpL;
134133
}
135134

136-
BOOST_CHECK( ZeroL < R1L );
137-
BOOST_CHECK( R2L < R1L );
138-
BOOST_CHECK( ZeroL < OneL );
139-
BOOST_CHECK( OneL < MaxL );
140-
BOOST_CHECK( R1L < MaxL );
141-
BOOST_CHECK( R2L < MaxL );
135+
BOOST_CHECK_LT(ZeroL, R1L);
136+
BOOST_CHECK_LT(R2L, R1L);
137+
BOOST_CHECK_LT(ZeroL, OneL);
138+
BOOST_CHECK_LT(OneL, MaxL);
139+
BOOST_CHECK_LT(R1L, MaxL);
140+
BOOST_CHECK_LT(R2L, MaxL);
142141

143142
uint160 LastS;
144143
for (int i = 159; i >= 0; --i) {
145144
uint160 TmpS;
146145
*(TmpS.begin() + (i>>3)) |= 1<<(7-(i&7));
147-
BOOST_CHECK( LastS < TmpS );
146+
BOOST_CHECK_LT(LastS, TmpS);
148147
LastS = TmpS;
149148
}
150-
BOOST_CHECK( ZeroS < R1S );
151-
BOOST_CHECK( R2S < R1S );
152-
BOOST_CHECK( ZeroS < OneS );
153-
BOOST_CHECK( OneS < MaxS );
154-
BOOST_CHECK( R1S < MaxS );
155-
BOOST_CHECK( R2S < MaxS );
149+
BOOST_CHECK_LT(ZeroS, R1S);
150+
BOOST_CHECK_LT(R2S, R1S);
151+
BOOST_CHECK_LT(ZeroS, OneS);
152+
BOOST_CHECK_LT(OneS, MaxS);
153+
BOOST_CHECK_LT(R1S, MaxS);
154+
BOOST_CHECK_LT(R2S, MaxS);
156155
}
157156

158157
BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() GetLow64 GetSerializeSize, Serialize, Unserialize
159158
{
160-
BOOST_CHECK(R1L.GetHex() == R1L.ToString());
161-
BOOST_CHECK(R2L.GetHex() == R2L.ToString());
162-
BOOST_CHECK(OneL.GetHex() == OneL.ToString());
163-
BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
159+
BOOST_CHECK_EQUAL(R1L.GetHex(), R1L.ToString());
160+
BOOST_CHECK_EQUAL(R2L.GetHex(), R2L.ToString());
161+
BOOST_CHECK_EQUAL(OneL.GetHex(), OneL.ToString());
162+
BOOST_CHECK_EQUAL(MaxL.GetHex(), MaxL.ToString());
164163
uint256 TmpL(R1L);
165-
BOOST_CHECK(TmpL == R1L);
166-
TmpL.SetHex(R2L.ToString()); BOOST_CHECK(TmpL == R2L);
167-
TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK(TmpL == uint256());
164+
BOOST_CHECK_EQUAL(TmpL, R1L);
165+
TmpL.SetHex(R2L.ToString()); BOOST_CHECK_EQUAL(TmpL, R2L);
166+
TmpL.SetHex(ZeroL.ToString()); BOOST_CHECK_EQUAL(TmpL, uint256());
168167

169168
TmpL.SetHex(R1L.ToString());
170-
BOOST_CHECK(memcmp(R1L.begin(), R1Array, 32)==0);
171-
BOOST_CHECK(memcmp(TmpL.begin(), R1Array, 32)==0);
172-
BOOST_CHECK(memcmp(R2L.begin(), R2Array, 32)==0);
173-
BOOST_CHECK(memcmp(ZeroL.begin(), ZeroArray, 32)==0);
174-
BOOST_CHECK(memcmp(OneL.begin(), OneArray, 32)==0);
175-
BOOST_CHECK(R1L.size() == sizeof(R1L));
176-
BOOST_CHECK(sizeof(R1L) == 32);
177-
BOOST_CHECK(R1L.size() == 32);
178-
BOOST_CHECK(R2L.size() == 32);
179-
BOOST_CHECK(ZeroL.size() == 32);
180-
BOOST_CHECK(MaxL.size() == 32);
181-
BOOST_CHECK(R1L.begin() + 32 == R1L.end());
182-
BOOST_CHECK(R2L.begin() + 32 == R2L.end());
183-
BOOST_CHECK(OneL.begin() + 32 == OneL.end());
184-
BOOST_CHECK(MaxL.begin() + 32 == MaxL.end());
185-
BOOST_CHECK(TmpL.begin() + 32 == TmpL.end());
186-
BOOST_CHECK(GetSerializeSize(R1L) == 32);
187-
BOOST_CHECK(GetSerializeSize(ZeroL) == 32);
169+
BOOST_CHECK_EQUAL_COLLECTIONS(R1L.begin(), R1L.end(), R1Array, R1Array + R1L.size());
170+
BOOST_CHECK_EQUAL_COLLECTIONS(TmpL.begin(), TmpL.end(), R1Array, R1Array + TmpL.size());
171+
BOOST_CHECK_EQUAL_COLLECTIONS(R2L.begin(), R2L.end(), R2Array, R2Array + R2L.size());
172+
BOOST_CHECK_EQUAL_COLLECTIONS(ZeroL.begin(), ZeroL.end(), ZeroArray, ZeroArray + ZeroL.size());
173+
BOOST_CHECK_EQUAL_COLLECTIONS(OneL.begin(), OneL.end(), OneArray, OneArray + OneL.size());
174+
BOOST_CHECK_EQUAL(R1L.size(), sizeof(R1L));
175+
BOOST_CHECK_EQUAL(sizeof(R1L), 32);
176+
BOOST_CHECK_EQUAL(R1L.size(), 32);
177+
BOOST_CHECK_EQUAL(R2L.size(), 32);
178+
BOOST_CHECK_EQUAL(ZeroL.size(), 32);
179+
BOOST_CHECK_EQUAL(MaxL.size(), 32);
180+
BOOST_CHECK_EQUAL(R1L.begin() + 32, R1L.end());
181+
BOOST_CHECK_EQUAL(R2L.begin() + 32, R2L.end());
182+
BOOST_CHECK_EQUAL(OneL.begin() + 32, OneL.end());
183+
BOOST_CHECK_EQUAL(MaxL.begin() + 32, MaxL.end());
184+
BOOST_CHECK_EQUAL(TmpL.begin() + 32, TmpL.end());
185+
BOOST_CHECK_EQUAL(GetSerializeSize(R1L), 32);
186+
BOOST_CHECK_EQUAL(GetSerializeSize(ZeroL), 32);
188187

189188
DataStream ss{};
190189
ss << R1L;
191-
BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+32));
190+
BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+32));
192191
ss >> TmpL;
193-
BOOST_CHECK(R1L == TmpL);
192+
BOOST_CHECK_EQUAL(R1L, TmpL);
194193
ss.clear();
195194
ss << ZeroL;
196-
BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+32));
195+
BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+32));
197196
ss >> TmpL;
198-
BOOST_CHECK(ZeroL == TmpL);
197+
BOOST_CHECK_EQUAL(ZeroL, TmpL);
199198
ss.clear();
200199
ss << MaxL;
201-
BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+32));
200+
BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+32));
202201
ss >> TmpL;
203-
BOOST_CHECK(MaxL == TmpL);
202+
BOOST_CHECK_EQUAL(MaxL, TmpL);
204203
ss.clear();
205204

206-
BOOST_CHECK(R1S.GetHex() == R1S.ToString());
207-
BOOST_CHECK(R2S.GetHex() == R2S.ToString());
208-
BOOST_CHECK(OneS.GetHex() == OneS.ToString());
209-
BOOST_CHECK(MaxS.GetHex() == MaxS.ToString());
205+
BOOST_CHECK_EQUAL(R1S.GetHex(), R1S.ToString());
206+
BOOST_CHECK_EQUAL(R2S.GetHex(), R2S.ToString());
207+
BOOST_CHECK_EQUAL(OneS.GetHex(), OneS.ToString());
208+
BOOST_CHECK_EQUAL(MaxS.GetHex(), MaxS.ToString());
210209
uint160 TmpS(R1S);
211-
BOOST_CHECK(TmpS == R1S);
212-
TmpS.SetHex(R2S.ToString()); BOOST_CHECK(TmpS == R2S);
213-
TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK(TmpS == uint160());
210+
BOOST_CHECK_EQUAL(TmpS, R1S);
211+
TmpS.SetHex(R2S.ToString()); BOOST_CHECK_EQUAL(TmpS, R2S);
212+
TmpS.SetHex(ZeroS.ToString()); BOOST_CHECK_EQUAL(TmpS, uint160());
214213

215214
TmpS.SetHex(R1S.ToString());
216-
BOOST_CHECK(memcmp(R1S.begin(), R1Array, 20)==0);
217-
BOOST_CHECK(memcmp(TmpS.begin(), R1Array, 20)==0);
218-
BOOST_CHECK(memcmp(R2S.begin(), R2Array, 20)==0);
219-
BOOST_CHECK(memcmp(ZeroS.begin(), ZeroArray, 20)==0);
220-
BOOST_CHECK(memcmp(OneS.begin(), OneArray, 20)==0);
221-
BOOST_CHECK(R1S.size() == sizeof(R1S));
222-
BOOST_CHECK(sizeof(R1S) == 20);
223-
BOOST_CHECK(R1S.size() == 20);
224-
BOOST_CHECK(R2S.size() == 20);
225-
BOOST_CHECK(ZeroS.size() == 20);
226-
BOOST_CHECK(MaxS.size() == 20);
227-
BOOST_CHECK(R1S.begin() + 20 == R1S.end());
228-
BOOST_CHECK(R2S.begin() + 20 == R2S.end());
229-
BOOST_CHECK(OneS.begin() + 20 == OneS.end());
230-
BOOST_CHECK(MaxS.begin() + 20 == MaxS.end());
231-
BOOST_CHECK(TmpS.begin() + 20 == TmpS.end());
232-
BOOST_CHECK(GetSerializeSize(R1S) == 20);
233-
BOOST_CHECK(GetSerializeSize(ZeroS) == 20);
215+
BOOST_CHECK_EQUAL_COLLECTIONS(R1S.begin(), R1S.end(), R1Array, R1Array + R1S.size());
216+
BOOST_CHECK_EQUAL_COLLECTIONS(TmpS.begin(), TmpS.end(), R1Array, R1Array + TmpS.size());
217+
BOOST_CHECK_EQUAL_COLLECTIONS(R2S.begin(), R2S.end(), R2Array, R2Array + R2S.size());
218+
BOOST_CHECK_EQUAL_COLLECTIONS(ZeroS.begin(), ZeroS.end(), ZeroArray, ZeroArray + ZeroS.size());
219+
BOOST_CHECK_EQUAL_COLLECTIONS(OneS.begin(), OneS.end(), OneArray, OneArray + OneS.size());
220+
BOOST_CHECK_EQUAL(R1S.size(), sizeof(R1S));
221+
BOOST_CHECK_EQUAL(sizeof(R1S), 20);
222+
BOOST_CHECK_EQUAL(R1S.size(), 20);
223+
BOOST_CHECK_EQUAL(R2S.size(), 20);
224+
BOOST_CHECK_EQUAL(ZeroS.size(), 20);
225+
BOOST_CHECK_EQUAL(MaxS.size(), 20);
226+
BOOST_CHECK_EQUAL(R1S.begin() + 20, R1S.end());
227+
BOOST_CHECK_EQUAL(R2S.begin() + 20, R2S.end());
228+
BOOST_CHECK_EQUAL(OneS.begin() + 20, OneS.end());
229+
BOOST_CHECK_EQUAL(MaxS.begin() + 20, MaxS.end());
230+
BOOST_CHECK_EQUAL(TmpS.begin() + 20, TmpS.end());
231+
BOOST_CHECK_EQUAL(GetSerializeSize(R1S), 20);
232+
BOOST_CHECK_EQUAL(GetSerializeSize(ZeroS), 20);
234233

235234
ss << R1S;
236-
BOOST_CHECK(ss.str() == std::string(R1Array,R1Array+20));
235+
BOOST_CHECK_EQUAL(ss.str(), std::string(R1Array,R1Array+20));
237236
ss >> TmpS;
238-
BOOST_CHECK(R1S == TmpS);
237+
BOOST_CHECK_EQUAL(R1S, TmpS);
239238
ss.clear();
240239
ss << ZeroS;
241-
BOOST_CHECK(ss.str() == std::string(ZeroArray,ZeroArray+20));
240+
BOOST_CHECK_EQUAL(ss.str(), std::string(ZeroArray,ZeroArray+20));
242241
ss >> TmpS;
243-
BOOST_CHECK(ZeroS == TmpS);
242+
BOOST_CHECK_EQUAL(ZeroS, TmpS);
244243
ss.clear();
245244
ss << MaxS;
246-
BOOST_CHECK(ss.str() == std::string(MaxArray,MaxArray+20));
245+
BOOST_CHECK_EQUAL(ss.str(), std::string(MaxArray,MaxArray+20));
247246
ss >> TmpS;
248-
BOOST_CHECK(MaxS == TmpS);
247+
BOOST_CHECK_EQUAL(MaxS, TmpS);
249248
ss.clear();
250249
}
251250

252251
BOOST_AUTO_TEST_CASE( conversion )
253252
{
254-
BOOST_CHECK(ArithToUint256(UintToArith256(ZeroL)) == ZeroL);
255-
BOOST_CHECK(ArithToUint256(UintToArith256(OneL)) == OneL);
256-
BOOST_CHECK(ArithToUint256(UintToArith256(R1L)) == R1L);
257-
BOOST_CHECK(ArithToUint256(UintToArith256(R2L)) == R2L);
258-
BOOST_CHECK(UintToArith256(ZeroL) == 0);
259-
BOOST_CHECK(UintToArith256(OneL) == 1);
260-
BOOST_CHECK(ArithToUint256(0) == ZeroL);
261-
BOOST_CHECK(ArithToUint256(1) == OneL);
262-
BOOST_CHECK(arith_uint256(UintToArith256(uint256S(R1L.GetHex()))) == UintToArith256(R1L));
263-
BOOST_CHECK(arith_uint256(UintToArith256(uint256S(R2L.GetHex()))) == UintToArith256(R2L));
264-
BOOST_CHECK(R1L.GetHex() == UintToArith256(R1L).GetHex());
265-
BOOST_CHECK(R2L.GetHex() == UintToArith256(R2L).GetHex());
253+
BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(ZeroL)), ZeroL);
254+
BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(OneL)), OneL);
255+
BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(R1L)), R1L);
256+
BOOST_CHECK_EQUAL(ArithToUint256(UintToArith256(R2L)), R2L);
257+
BOOST_CHECK_EQUAL(UintToArith256(ZeroL), 0);
258+
BOOST_CHECK_EQUAL(UintToArith256(OneL), 1);
259+
BOOST_CHECK_EQUAL(ArithToUint256(0), ZeroL);
260+
BOOST_CHECK_EQUAL(ArithToUint256(1), OneL);
261+
BOOST_CHECK_EQUAL(arith_uint256(UintToArith256(uint256S(R1L.GetHex()))), UintToArith256(R1L));
262+
BOOST_CHECK_EQUAL(arith_uint256(UintToArith256(uint256S(R2L.GetHex()))), UintToArith256(R2L));
263+
BOOST_CHECK_EQUAL(R1L.GetHex(), UintToArith256(R1L).GetHex());
264+
BOOST_CHECK_EQUAL(R2L.GetHex(), UintToArith256(R2L).GetHex());
266265
}
267266

268267
BOOST_AUTO_TEST_CASE( operator_with_self )
@@ -285,13 +284,13 @@ BOOST_AUTO_TEST_CASE( operator_with_self )
285284
#endif
286285
arith_uint256 v = UintToArith256(uint256S("02"));
287286
v *= v;
288-
BOOST_CHECK(v == UintToArith256(uint256S("04")));
287+
BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("04")));
289288
v /= v;
290-
BOOST_CHECK(v == UintToArith256(uint256S("01")));
289+
BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("01")));
291290
v += v;
292-
BOOST_CHECK(v == UintToArith256(uint256S("02")));
291+
BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("02")));
293292
v -= v;
294-
BOOST_CHECK(v == UintToArith256(uint256S("0")));
293+
BOOST_CHECK_EQUAL(v, UintToArith256(uint256S("0")));
295294
#if defined(__clang__)
296295
# pragma clang diagnostic pop
297296
#endif

‎src/test/util/setup_common.cpp

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,18 @@ const std::function<std::string(const char*)> G_TRANSLATION_FUN = nullptr;
7979
/** Random context to get unique temp data dirs. Separate from g_insecure_rand_ctx, which can be seeded from a const env var */
8080
static FastRandomContext g_insecure_rand_ctx_temp_path;
8181

82+
std::ostream& operator<<(std::ostream& os, const arith_uint256& num)
83+
{
84+
os << ArithToUint256(num).ToString();
85+
return os;
86+
}
87+
88+
std::ostream& operator<<(std::ostream& os, const uint160& num)
89+
{
90+
os << num.ToString();
91+
return os;
92+
}
93+
8294
std::ostream& operator<<(std::ostream& os, const uint256& num)
8395
{
8496
os << num.ToString();

‎src/test/util/setup_common.h

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@
2424
#include <type_traits>
2525
#include <vector>
2626

27+
class arith_uint256;
2728
class CFeeRate;
2829
class Chainstate;
2930
class FastRandomContext;
@@ -234,7 +235,9 @@ std::unique_ptr<T> MakeNoLogFileContext(const ChainType chain_type = ChainType::
234235

235236
CBlock getBlock13b8a();
236237

237-
// define an implicit conversion here so that uint256 may be used directly in BOOST_CHECK_*
238+
// Make types usable in BOOST_CHECK_*
239+
std::ostream& operator<<(std::ostream& os, const arith_uint256& num);
240+
std::ostream& operator<<(std::ostream& os, const uint160& num);
238241
std::ostream& operator<<(std::ostream& os, const uint256& num);
239242

240243
/**

0 commit comments

Comments
 (0)