?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Upstream tarball 10026
[amule.git] / unittests / tests / CUInt128Test.cpp
blob9260b94c38528e9bc3ac36bc599d1649d38799dd
1 // -*- C++ -*-
2 // This file is part of the aMule Project.
3 //
4 // Copyright (c) 2008 Dévai Tamás ( gonosztopi@amule.org )
5 // Copyright (c) 2008 aMule Team ( admin@amule.org / http://www.amule.org )
6 //
7 // Any parts of this program derived from the xMule, lMule or eMule project,
8 // or contributed by third-party developers are copyrighted by their
9 // respective authors.
10 //
11 // This program is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation; either version 2 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 //
25
26 #include <muleunit/test.h>
27 #include <kademlia/utils/UInt128.h>
28
29 using namespace muleunit;
30 using Kademlia::CUInt128;
31
32 namespace muleunit {
33 // Needed for ASSERT_EQUALS with CUInt128
34 template<> wxString StringFrom<CUInt128>(const CUInt128& value) {
35 return value.ToHexString();
36 }
37
38 typedef uint8_t ByteArray[16];
39 // Needed for ASSERT_EQUALS with uint8_t[16]
40 template<> wxString StringFrom<ByteArray>(const ByteArray& value) {
41 wxString retval;
42 for (int i = 0; i < 16; i++) {
43 if (i) {
44 retval.Append(wxString::Format(wxT(" %02X"), value[i]));
45 } else {
46 retval.Append(wxString::Format(wxT("%02X"), value[i]));
47 }
48 }
49 return retval;
50 }
51 }
52
53 // Put static test data into a namespace to avoid possible clash with muleunit namespace
54 namespace TestData {
55 static uint8_t sequence[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf };
56 static uint8_t zero[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
57 static uint8_t one[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
58 static uint8_t minusOne[16] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
59 static uint8_t uintValue[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x12, 0x34, 0x56, 0x78 };
60 static uint8_t randomValue[16] = { 0xef, 0xac, 0xd6, 0x21, 0x99, 0x1b, 0x05, 0xbe, 0xfb, 0x97, 0xdf, 0xdd, 0xab, 0x4b, 0x88, 0xe3 };
61 }
62
63 DECLARE_SIMPLE(CUInt128);
64
65 // Each test uses only functionality previously tested.
66
67 TEST_M(CUInt128, ConstructorAndToByteArray, wxT("Reading/writing byte sequences"))
68 {
69 uint8_t result[16];
70
71 CUInt128 test((uint8_t *)&TestData::sequence);
72 test.ToByteArray((uint8_t *)&result);
73 ASSERT_TRUE_M(TestData::sequence[0] == result[0] &&
74 TestData::sequence[1] == result[1] &&
75 TestData::sequence[2] == result[2] &&
76 TestData::sequence[3] == result[3] &&
77 TestData::sequence[4] == result[4] &&
78 TestData::sequence[5] == result[5] &&
79 TestData::sequence[6] == result[6] &&
80 TestData::sequence[7] == result[7] &&
81 TestData::sequence[8] == result[8] &&
82 TestData::sequence[9] == result[9] &&
83 TestData::sequence[10] == result[10] &&
84 TestData::sequence[11] == result[11] &&
85 TestData::sequence[12] == result[12] &&
86 TestData::sequence[13] == result[13] &&
87 TestData::sequence[14] == result[14] &&
88 TestData::sequence[15] == result[15],
89 wxString(wxT("Expected '")) + StringFrom(TestData::sequence) + wxT("' but got '") + StringFrom(result) + wxT("'"));
90 }
91
92 TEST(CUInt128, ToHexString)
93 {
94 CUInt128 test((uint8_t *)&TestData::sequence);
95 ASSERT_EQUALS(wxT("000102030405060708090A0B0C0D0E0F"), test.ToHexString());
96 }
97
98 TEST(CUInt128, ToBinaryString)
99 {
100 CUInt128 test((uint8_t *)&TestData::sequence);
101 ASSERT_EQUALS(wxT("00000000000000010000001000000011000001000000010100000110000001110000100000001001000010100000101100001100000011010000111000001111"), test.ToBinaryString());
102 ASSERT_EQUALS(wxT("10000001000000011000001000000010100000110000001110000100000001001000010100000101100001100000011010000111000001111"), test.ToBinaryString(true));
103 CUInt128 testZero((uint8_t *)&TestData::zero);
104 ASSERT_EQUALS(wxT("0"), testZero.ToBinaryString(true));
105 }
106
107 TEST(CUInt128, Get32BitChunk)
108 {
109 CUInt128 test((uint8_t *)&TestData::sequence);
110 ASSERT_EQUALS(0x00010203u, test.Get32BitChunk(0));
111 ASSERT_EQUALS(0x04050607u, test.Get32BitChunk(1));
112 ASSERT_EQUALS(0x08090a0bu, test.Get32BitChunk(2));
113 ASSERT_EQUALS(0x0c0d0e0fu, test.Get32BitChunk(3));
114 #if wxCHECK_VERSION(2, 8, 8)
115 ASSERT_RAISES(CAssertFailureException, test.Get32BitChunk(4));
116 #endif
117 }
118
119 TEST_M(CUInt128, OperatorEqualsCUInt128, wxT("operator==(const CUInt128&)"))
120 {
121 CUInt128 a((uint8_t *)&TestData::sequence);
122 CUInt128 b((uint8_t *)&TestData::one);
123
124 ASSERT_TRUE(a == a);
125 ASSERT_FALSE(a == b);
126 }
127
128 TEST_M(CUInt128, OperatorEqualsUint32, wxT("operator==(uint32_t)"))
129 {
130 ASSERT_TRUE(CUInt128((uint8_t *)&TestData::uintValue) == 0x12345678u);
131 CUInt128 test((uint8_t *)&TestData::sequence);
132 ASSERT_FALSE(test == 0x00010203u);
133 ASSERT_FALSE(test == 0x04050607u);
134 ASSERT_FALSE(test == 0x08090a0bu);
135 ASSERT_FALSE(test == 0x0c0d0e0fu);
136 }
137
138 TEST_M(CUInt128, OperatorEqualsUint32CUInt128, wxT("operator==(uint32_t, const CUInt128&)"))
139 {
140 ASSERT_TRUE(0x12345678u == CUInt128((uint8_t *)&TestData::uintValue));
141 CUInt128 test((uint8_t *)&TestData::sequence);
142 ASSERT_FALSE(0x00010203u == test);
143 ASSERT_FALSE(0x04050607u == test);
144 ASSERT_FALSE(0x08090a0bu == test);
145 ASSERT_FALSE(0x0c0d0e0fu == test);
146 }
147
148 TEST_M(CUInt128, EmptyContructor, wxT("CUInt128()"))
149 {
150 CUInt128 test;
151 CUInt128 ref((uint8_t *)&TestData::zero);
152
153 ASSERT_EQUALS(ref, test);
154 }
155
156 TEST_M(CUInt128, CopyConstructor, wxT("CUInt128(const CUInt128&)"))
157 {
158 CUInt128 a((uint8_t *)&TestData::sequence);
159 CUInt128 b(a);
160
161 ASSERT_EQUALS(a, b);
162 }
163
164 TEST_M(CUInt128, ConstructFromBool, wxT("CUInt128(bool)"))
165 {
166 CUInt128 empty(false);
167 CUInt128 full(true);
168 CUInt128 zero((uint8_t *)&TestData::zero);
169 CUInt128 minusOne((uint8_t *)&TestData::minusOne);
170
171 ASSERT_EQUALS(zero, empty);
172 ASSERT_EQUALS(minusOne, full);
173 }
174
175 TEST_M(CUInt128, ConstructFromUint32, wxT("CUInt128(uint32_t)"))
176 {
177 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::uintValue), CUInt128(0x12345678u));
178 }
179
180 TEST_M(CUInt128, AssignCUInt128, wxT("operator=(const CUInt128&)"))
181 {
182 CUInt128 a((uint8_t *)&TestData::sequence);
183 CUInt128 b = a;
184
185 ASSERT_EQUALS(a, b);
186 }
187
188 TEST_M(CUInt128, AssignUint32, wxT("operator=(uint32_t)"))
189 {
190 CUInt128 a((uint8_t *)&TestData::uintValue);
191 // Note that CUInt128 b = 0x12345678u; won't work,
192 // the compiler only allows assignment between the
193 // same types when constructing the object.
194 CUInt128 b;
195 b = 0x12345678u;
196
197 ASSERT_EQUALS(a, b);
198 }
199
200 TEST(CUInt128, Set32BitChunk)
201 {
202 CUInt128 test;
203
204 test.Set32BitChunk(3, 0x12345678u);
205 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::uintValue), test);
206
207 test.Set32BitChunk(0, 0x00010203u);
208 test.Set32BitChunk(1, 0x04050607u);
209 test.Set32BitChunk(2, 0x08090a0bu);
210 test.Set32BitChunk(3, 0x0c0d0e0fu);
211 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
212 #if wxCHECK_VERSION(2, 8, 8)
213 ASSERT_RAISES(CAssertFailureException, test.Set32BitChunk(4, 0));
214 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
215 #endif
216 }
217
218 TEST_M(CUInt128, SetValueCUInt128, wxT("SetValue(const CUInt128&)"))
219 {
220 CUInt128 a((uint8_t *)&TestData::sequence);
221 CUInt128 b;
222
223 b.SetValue(a);
224 ASSERT_EQUALS(a, b);
225 }
226
227 TEST_M(CUInt128, SetValueUint32, wxT("SetValue(uint32_t)"))
228 {
229 CUInt128 a((uint8_t *)&TestData::uintValue);
230 CUInt128 b;
231
232 b.SetValue(0x12345678u);
233 ASSERT_EQUALS(a, b);
234 }
235
236 TEST(CUInt128, SetValueBE)
237 {
238 CUInt128 a((uint8_t *)&TestData::sequence);
239 CUInt128 b;
240 uint8_t buffer[16];
241
242 a.ToByteArray((uint8_t *)&buffer);
243 b.SetValueBE((uint8_t *)&buffer);
244 ASSERT_EQUALS(a, b);
245 }
246
247 TEST(CUInt128, StoreCryptValue)
248 {
249 uint8_t ref[16] = { 0x3, 0x2, 0x1, 0x0, 0x7, 0x6, 0x5, 0x4, 0xb, 0xa, 0x9, 0x8, 0xf, 0xe, 0xd, 0xc };
250 uint8_t tmp[16];
251 CUInt128 test((uint8_t *)&TestData::sequence);
252
253 test.StoreCryptValue((uint8_t *)&tmp);
254 ASSERT_EQUALS(CUInt128((uint8_t *)&ref), CUInt128((uint8_t *)&tmp));
255 }
256
257 TEST(CUInt128, ShiftLeft)
258 {
259 CUInt128 test((uint8_t *)&TestData::one);
260 uint8_t r1[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 };
261 uint8_t r2[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 };
262 uint8_t r3[16] = { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
263 uint8_t r4[16] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
264
265 test.ShiftLeft(0);
266 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::one), test);
267 test.ShiftLeft(1);
268 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), test);
269 test.ShiftLeft(32);
270 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), test);
271 test.ShiftLeft(58);
272 ASSERT_EQUALS(CUInt128((uint8_t *)&r3), test);
273 test.SetValueBE((uint8_t *)&TestData::one);
274 test.ShiftLeft(127);
275 ASSERT_EQUALS(CUInt128((uint8_t *)&r4), test);
276 test.SetValueBE((uint8_t *)&TestData::one);
277 test.ShiftLeft(128);
278 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::zero), test);
279 }
280
281 TEST_M(CUInt128, AddCUInt128, wxT("Add(const CUInt128&)"))
282 {
283 uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
284 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
285 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
286 uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
287 uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
288 CUInt128 a((uint8_t *)&TestData::sequence);
289 CUInt128 d((uint8_t *)&d0);
290
291 a.Add(CUInt128(0x01234567u));
292 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
293 a.Add(CUInt128(0xff000000u));
294 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
295 a.Add(d);
296 ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
297 ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
298 a.Add(d);
299 ASSERT_EQUALS(CUInt128((uint8_t *)&r4), a);
300 a.SetValueBE((uint8_t *)&TestData::minusOne);
301 a.Add(CUInt128((uint8_t *)&TestData::one));
302 ASSERT_EQUALS(CUInt128(), a);
303 }
304
305 TEST_M(CUInt128, AddUint32, wxT("Add(uint32_t)"))
306 {
307 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
308 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
309 CUInt128 a((uint8_t *)&TestData::sequence);
310
311 a.Add(0x01234567u);
312 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
313 a.Add(0xff000000u);
314 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
315 a.SetValueBE((uint8_t *)&TestData::minusOne);
316 a.Add(1u);
317 ASSERT_EQUALS(0, a);
318 }
319
320 TEST_M(CUInt128, SubtractCUInt128, wxT("Subtract(const CUInt128&)"))
321 {
322 uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
323 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
324 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
325 uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
326 uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
327 CUInt128 a((uint8_t *)&r4);
328 CUInt128 d((uint8_t *)&d0);
329
330 a.Subtract(d);
331 ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
332 ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
333 a.Subtract(d);
334 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
335 a.Subtract(CUInt128(0xff000000u));
336 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
337 a.Subtract(CUInt128(0x01234567u));
338 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
339 a.SetValue(0u);
340 a.Subtract(CUInt128((uint8_t *)&TestData::one));
341 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
342 }
343
344 TEST_M(CUInt128, SubtractUint32, wxT("Subtract(uint32_t)"))
345 {
346 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
347 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
348 CUInt128 a((uint8_t *)&r2);
349
350 a.Subtract(0xff000000u);
351 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
352 a.Subtract(0x01234567u);
353 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
354 a.SetValue(0u);
355 a.Subtract(1u);
356 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
357 }
358
359 TEST_M(CUInt128, XorCUInt128, wxT("XOR(const CUInt128&)"))
360 {
361 uint8_t xd[16] = { 0xff, 0x00, 0xee, 0x11, 0xdd, 0x22, 0xcc, 0x33, 0xbb, 0x44, 0xaa, 0x55, 0x99, 0x66, 0x88, 0x77 };
362 uint8_t xr[16] = { 0xff, 0x01, 0xec, 0x12, 0xd9, 0x27, 0xca, 0x34, 0xb3, 0x4d, 0xa0, 0x5e, 0x95, 0x6b, 0x86, 0x78 };
363 CUInt128 a((uint8_t *)&TestData::sequence);
364 CUInt128 x((uint8_t *)&xd);
365
366 a.XOR(x);
367 ASSERT_EQUALS(CUInt128((uint8_t *)&xr), a);
368 ASSERT_EQUALS(CUInt128((uint8_t *)&xd), x);
369 }
370
371 // Not yet implemented
372 #if 0
373 TEST_M(CUInt128, XorUint32, wxT("XOR(uint32_t)"))
374 {
375 CUInt128 a(0x12345678u);
376
377 a.XOR(0x76543210u);
378 ASSERT_EQUALS(0x64606468, a);
379 }
380 #endif
381
382 TEST_M(CUInt128, OperatorShiftLeftAssign, wxT("operator<<=(unsigned)"))
383 {
384 CUInt128 test((uint8_t *)&TestData::one);
385 uint8_t r1[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 };
386 uint8_t r2[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 };
387 uint8_t r3[16] = { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
388 uint8_t r4[16] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
389
390 test <<= 0;
391 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::one), test);
392 test <<= 1;
393 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), test);
394 test <<= 32;
395 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), test);
396 test <<= 58;
397 ASSERT_EQUALS(CUInt128((uint8_t *)&r3), test);
398 test.SetValueBE((uint8_t *)&TestData::one);
399 test <<= 127;
400 ASSERT_EQUALS(CUInt128((uint8_t *)&r4), test);
401 test.SetValueBE((uint8_t *)&TestData::one);
402 test <<= 128;
403 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::zero), test);
404 }
405
406 TEST_M(CUInt128, OperatorAddAssignCUInt128, wxT("operator+=(const CUInt128&)"))
407 {
408 uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
409 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
410 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
411 uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
412 uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
413 CUInt128 a((uint8_t *)&TestData::sequence);
414 CUInt128 d((uint8_t *)&d0);
415
416 a += CUInt128(0x01234567u);
417 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
418 a += CUInt128(0xff000000u);
419 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
420 a += d;
421 ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
422 ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
423 a += d;
424 ASSERT_EQUALS(CUInt128((uint8_t *)&r4), a);
425 a.SetValueBE((uint8_t *)&TestData::minusOne);
426 a += CUInt128((uint8_t *)&TestData::one);
427 ASSERT_EQUALS(CUInt128(), a);
428 }
429
430 TEST_M(CUInt128, OperatorAddAssignUint32, wxT("operator+=(uint32_t)"))
431 {
432 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
433 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
434 CUInt128 a((uint8_t *)&TestData::sequence);
435
436 a += 0x01234567u;
437 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
438 a += 0xff000000u;
439 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
440 a.SetValueBE((uint8_t *)&TestData::minusOne);
441 a += 1;
442 ASSERT_EQUALS(0, a);
443 }
444
445 TEST_M(CUInt128, OperatorSubtractAssignCUInt128, wxT("operator-=(const CUInt128&)"))
446 {
447 uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
448 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
449 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
450 uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
451 uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
452 CUInt128 a((uint8_t *)&r4);
453 CUInt128 d((uint8_t *)&d0);
454
455 a -= d;
456 ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
457 ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
458 a -= d;
459 ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
460 a -= CUInt128(0xff000000u);
461 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
462 a -= CUInt128(0x01234567u);
463 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
464 a.SetValue(0u);
465 a -= CUInt128((uint8_t *)&TestData::one);
466 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
467 }
468
469 TEST_M(CUInt128, OperatorSubtractAssignUint32, wxT("operator-=(uint32_t)"))
470 {
471 uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
472 uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
473 CUInt128 a((uint8_t *)&r2);
474
475 a -= 0xff000000u;
476 ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
477 a -= 0x01234567u;
478 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
479 a = 0;
480 a -= 1;
481 ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
482 }
483
484 TEST_M(CUInt128, OperatorXorAssignCUInt128, wxT("operator^=(const CUInt128&)"))
485 {
486 uint8_t xd[16] = { 0xff, 0x00, 0xee, 0x11, 0xdd, 0x22, 0xcc, 0x33, 0xbb, 0x44, 0xaa, 0x55, 0x99, 0x66, 0x88, 0x77 };
487 uint8_t xr[16] = { 0xff, 0x01, 0xec, 0x12, 0xd9, 0x27, 0xca, 0x34, 0xb3, 0x4d, 0xa0, 0x5e, 0x95, 0x6b, 0x86, 0x78 };
488 CUInt128 a((uint8_t *)&TestData::sequence);
489 CUInt128 x((uint8_t *)&xd);
490
491 a ^= x;
492 ASSERT_EQUALS(CUInt128((uint8_t *)&xr), a);
493 ASSERT_EQUALS(CUInt128((uint8_t *)&xd), x);
494 }
495
496 TEST_M(CUInt128, OperatorXorAssignUint32, wxT("operator^=(uint32_t)"))
497 {
498 CUInt128 a(0x12345678u);
499
500 a ^= 0x76543210u;
501 ASSERT_EQUALS(0x64606468, a);
502 }
503
504 TEST(CUInt128, GetBitNumber)
505 {
506 CUInt128 test;
507 test = 1;
508
509 ASSERT_TRUE(test.GetBitNumber(0) == 0);
510 ASSERT_TRUE(test.GetBitNumber(127) == 1);
511 test <<= 127;
512 ASSERT_TRUE(test.GetBitNumber(0) == 1);
513 ASSERT_TRUE(test.GetBitNumber(127) == 0);
514 }
515
516 TEST(CUInt128, SetBitNumber)
517 {
518 CUInt128 test;
519
520 test.SetBitNumber(127, 1);
521 ASSERT_EQUALS(1, test);
522 test.SetBitNumber(126, 1);
523 ASSERT_EQUALS(3, test);
524 test.SetBitNumber(127, 0);
525 ASSERT_EQUALS(2, test);
526 test.SetBitNumber(0, 1);
527 ASSERT_EQUALS(0x80000000u, test.Get32BitChunk(0));
528 #if wxCHECK_VERSION(2, 8, 8)
529 ASSERT_RAISES(CAssertFailureException, test.SetBitNumber(128, 0));
530 #endif
531 }
532
533 TEST_M(CUInt128, OperatorNotEqualCUInt128, wxT("operator!=(const CUInt128&)"))
534 {
535 CUInt128 a((uint8_t *)&TestData::sequence);
536 CUInt128 b((uint8_t *)&TestData::one);
537
538 ASSERT_FALSE(a != a);
539 ASSERT_TRUE(a != b);
540 }
541
542 TEST_M(CUInt128, OperatorNotEqualUint32, wxT("operator!=(uint32_t)"))
543 {
544 ASSERT_FALSE(CUInt128((uint8_t *)&TestData::uintValue) != 0x12345678u);
545 CUInt128 test((uint8_t *)&TestData::sequence);
546 ASSERT_TRUE(test != 0x00010203u);
547 ASSERT_TRUE(test != 0x04050607u);
548 ASSERT_TRUE(test != 0x08090a0bu);
549 ASSERT_TRUE(test != 0x0c0d0e0fu);
550 }
551
552 TEST_M(CUInt128, OperatorNotEqualUint32CUInt128, wxT("operator!=(uint32_t, const CUInt128&)"))
553 {
554 ASSERT_FALSE(0x12345678u != CUInt128((uint8_t *)&TestData::uintValue));
555 CUInt128 test((uint8_t *)&TestData::sequence);
556 ASSERT_TRUE(0x00010203u != test);
557 ASSERT_TRUE(0x04050607u != test);
558 ASSERT_TRUE(0x08090a0bu != test);
559 ASSERT_TRUE(0x0c0d0e0fu != test);
560 }
561
562 TEST_M(CUInt128, OperatorLessCUInt128, wxT("operator<(const CUInt128&)"))
563 {
564 for (unsigned i = 0; i < 4; i++) {
565 CUInt128 a;
566 CUInt128 b;
567 a.Set32BitChunk(i, 0x0d3859feu);
568 b.Set32BitChunk(i, 0xff579ec1u);
569 ASSERT_TRUE(a < b);
570 }
571 }
572
573 TEST_M(CUInt128, OperatorLessOrEqualCUInt128, wxT("operator<=(const CUInt128&)"))
574 {
575 for (unsigned i = 0; i < 4; i++) {
576 CUInt128 a;
577 CUInt128 b;
578 a.Set32BitChunk(i, 0x0d3859feu);
579 b.Set32BitChunk(i, 0xff579ec1u);
580 ASSERT_TRUE(a <= b);
581 b.Set32BitChunk(i, a.Get32BitChunk(i));
582 ASSERT_TRUE(a <= b);
583 }
584 }
585
586 TEST_M(CUInt128, OperatorGreaterCUInt128, wxT("operator>(const CUInt128&)"))
587 {
588 for (unsigned i = 0; i < 4; i++) {
589 CUInt128 a;
590 CUInt128 b;
591 b.Set32BitChunk(i, 0x0d3859feu);
592 a.Set32BitChunk(i, 0xff579ec1u);
593 ASSERT_TRUE(a > b);
594 }
595 }
596
597 TEST_M(CUInt128, OperatorGreaterOrEqualCUInt128, wxT("operator>=(const CUInt128&)"))
598 {
599 for (unsigned i = 0; i < 4; i++) {
600 CUInt128 a;
601 CUInt128 b;
602 b.Set32BitChunk(i, 0x0d3859feu);
603 a.Set32BitChunk(i, 0xff579ec1u);
604 ASSERT_TRUE(a >= b);
605 b.Set32BitChunk(i, a.Get32BitChunk(i));
606 ASSERT_TRUE(a >= b);
607 }
608 }
609
610 TEST_M(CUInt128, OperatorLessUint32, wxT("operator<(uint32_t)"))
611 {
612 for (unsigned i = 0; i < 4; i++) {
613 CUInt128 a;
614 a.Set32BitChunk(i, 0x0d3859feu);
615 if (i == 3) {
616 ASSERT_TRUE(a < 0xffed3216u);
617 } else {
618 ASSERT_FALSE(a < 0xffed3216u);
619 }
620 }
621 }
622
623 TEST_M(CUInt128, OperatorLessOrEqualUint32, wxT("operator<=(uint32_t)"))
624 {
625 for (unsigned i = 0; i < 4; i++) {
626 CUInt128 a;
627 a.Set32BitChunk(i, 0x0d3859feu);
628 if (i == 3) {
629 ASSERT_TRUE(a <= 0xffed3216u);
630 ASSERT_TRUE(a <= 0x0d3859feu);
631 } else {
632 ASSERT_FALSE(a <= 0xffed3216u);
633 ASSERT_FALSE(a <= 0x0d3859feu);
634 }
635 }
636 }
637
638 TEST_M(CUInt128, OperatorGreaterUint32, wxT("operator>(uint32_t)"))
639 {
640 for (unsigned i = 0; i < 4; i++) {
641 CUInt128 a;
642 a.Set32BitChunk(i, 0xffed3216u);
643 ASSERT_TRUE(a > 0x0d3859feu);
644 }
645 }
646
647 TEST_M(CUInt128, OperatorGreaterOrEqualUint32, wxT("operator>=(uint32_t)"))
648 {
649 for (unsigned i = 0; i < 4; i++) {
650 CUInt128 a;
651 a.Set32BitChunk(i, 0xffed3216u);
652 ASSERT_TRUE(a >= 0x0d3859feu);
653 ASSERT_TRUE(a >= 0xffed3216u);
654 }
655 }
656
657 TEST_M(CUInt128, OperatorLessUint32CUInt128, wxT("operator<(uint32_t, const CUInt128&)"))
658 {
659 for (unsigned i = 0; i < 4; i++) {
660 CUInt128 a;
661 a.Set32BitChunk(i, 0xffed3216u);
662 ASSERT_TRUE(a > 0x0d3859feu);
663 }
664 }
665
666 TEST_M(CUInt128, OperatorLessOrEqualUint32CUInt128, wxT("operator<=(uint32_t, const CUInt128&)"))
667 {
668 for (unsigned i = 0; i < 4; i++) {
669 CUInt128 a;
670 a.Set32BitChunk(i, 0xffed3216u);
671 ASSERT_TRUE(0x0d3859feu <= a);
672 ASSERT_TRUE(0xffed3216u <= a);
673 }
674 }
675
676 TEST_M(CUInt128, OperatorGreaterUint32CUInt128, wxT("operator>(uint32_t, const CUInt128&)"))
677 {
678 for (unsigned i = 0; i < 4; i++) {
679 CUInt128 a;
680 a.Set32BitChunk(i, 0x0d3859feu);
681 if (i == 3) {
682 ASSERT_TRUE(0xffed3216u > a);
683 } else {
684 ASSERT_FALSE(0xffed3216u > a);
685 }
686 }
687 }
688
689 TEST_M(CUInt128, OperatorGreaterOrEqualUint32CUInt128, wxT("operator>=(uint32_t, const CUInt128&)"))
690 {
691 for (unsigned i = 0; i < 4; i++) {
692 CUInt128 a;
693 a.Set32BitChunk(i, 0x0d3859feu);
694 if (i == 3) {
695 ASSERT_TRUE(0xffed3216u >= a);
696 ASSERT_TRUE(0x0d3859feu >= a);
697 } else {
698 ASSERT_FALSE(0xffed3216u >= a);
699 ASSERT_FALSE(0x0d3859feu >= a);
700 }
701 }
702 }
703
704 TEST_M(CUInt128, OperatorAddCUInt128, wxT("operator+(const CUInt128&)"))
705 {
706 CUInt128 a((uint8_t *)&TestData::sequence);
707
708 CUInt128 ref(a);
709 CUInt128 check(a);
710
711 CUInt128 result(a + a);
712 check.Add(ref);
713 ASSERT_EQUALS(check, result);
714 ASSERT_EQUALS(ref, a);
715
716 a = ref;
717 a.SetBitNumber(32, 1);
718 check = a;
719 check += a;
720 result = a + a;
721 ASSERT_EQUALS(check, result);
722 }
723
724 TEST_M(CUInt128, OperatorSubtractCUInt128, wxT("operator-(const CUInt128&)"))
725 {
726 CUInt128 a((uint8_t *)&TestData::randomValue);
727 CUInt128 b((uint8_t *)&TestData::sequence);
728
729 CUInt128 refa(a);
730 CUInt128 refb(b);
731 CUInt128 check(a);
732
733 CUInt128 result(a - b);
734 ASSERT_EQUALS(refa, a);
735 ASSERT_EQUALS(refb, b);
736 check.Subtract(b);
737 ASSERT_EQUALS(check, result);
738
739 result = b - a;
740 check = b;
741 check -= a;
742 ASSERT_EQUALS(check, result);
743 }
744
745 TEST_M(CUInt128, OperatorXorCUInt128, wxT("operator^(const CUInt128&)"))
746 {
747 CUInt128 a((uint8_t *)&TestData::randomValue);
748 CUInt128 b((uint8_t *)&TestData::sequence);
749
750 CUInt128 refa(a);
751 CUInt128 refb(b);
752
753 CUInt128 result(a ^ b);
754 CUInt128 check(refa);
755 check ^= refb;
756
757 ASSERT_EQUALS(refa, a);
758 ASSERT_EQUALS(refb, b);
759 ASSERT_EQUALS(check, result);
760 }
761
762 TEST_M(CUInt128, OperatorAddUint32, wxT("operator+(uint32_t)"))
763 {
764 CUInt128 a((uint8_t *)&TestData::randomValue);
765 uint32_t b = a.Get32BitChunk(0);
766
767 CUInt128 ref(a);
768 CUInt128 check(a);
769
770 CUInt128 result(a + b);
771 check.Add(b);
772 ASSERT_EQUALS(check, result);
773 ASSERT_EQUALS(ref, a);
774
775 a = ref;
776 a.SetBitNumber(96, 1);
777 b = a.Get32BitChunk(3);
778 check = a;
779 check += b;
780 result = a + b;
781 ASSERT_EQUALS(check, result);
782 }
783
784 TEST_M(CUInt128, OperatorSubtractUint32, wxT("operator-(uint32_t)"))
785 {
786 CUInt128 a((uint8_t *)&TestData::randomValue);
787 uint32_t b = a.Get32BitChunk(0);
788
789 CUInt128 ref(a);
790 CUInt128 check(a);
791
792 CUInt128 result(a - b);
793 ASSERT_EQUALS(ref, a);
794 check.Subtract(b);
795 ASSERT_EQUALS(check, result);
796
797 result = a - ~b;
798 check = a;
799 check -= ~b;
800 ASSERT_EQUALS(check, result);
801 }
802
803 TEST_M(CUInt128, OperatorXorUint32, wxT("operator^(uint32_t)"))
804 {
805 CUInt128 a((uint8_t *)&TestData::randomValue);
806 uint32_t b = a.Get32BitChunk(0);
807
808 CUInt128 ref(a);
809
810 CUInt128 result(a ^ b);
811 CUInt128 check(ref);
812 check ^= b;
813
814 ASSERT_EQUALS(ref, a);
815 ASSERT_EQUALS(check, result);
816 }
817
818 TEST_M(CUInt128, OperatorAddUint32CUInt128, wxT("operator+(uint32_t, const CUInt128&)"))
819 {
820 CUInt128 a((uint8_t *)&TestData::randomValue);
821 uint32_t b = a.Get32BitChunk(0);
822
823 CUInt128 ref(a);
824 CUInt128 check(b);
825
826 CUInt128 result(b + a);
827 check.Add(a);
828 ASSERT_EQUALS(check, result);
829 ASSERT_EQUALS(ref, a);
830
831 a = ref;
832 a.SetBitNumber(96, 1);
833 b = a.Get32BitChunk(3);
834 check = b;
835 check += a;
836 result = b + a;
837 ASSERT_EQUALS(check, result);
838 }
839
840 TEST_M(CUInt128, OperatorSubtractUint32CUInt128, wxT("operator-(uint32_t, const CUInt128&)"))
841 {
842 CUInt128 a((uint8_t *)&TestData::randomValue);
843 uint32_t b = a.Get32BitChunk(0);
844
845 CUInt128 ref(a);
846 CUInt128 check(b);
847
848 CUInt128 result(b - a);
849 ASSERT_EQUALS(ref, a);
850 check.Subtract(a);
851 ASSERT_EQUALS(check, result);
852 }
853
854 TEST_M(CUInt128, OperatorXorUint32CUInt128, wxT("operator^(uint32_t, const CUInt128&)"))
855 {
856 CUInt128 a((uint8_t *)&TestData::randomValue);
857 uint32_t b = a.Get32BitChunk(0);
858
859 CUInt128 ref(a);
860 CUInt128 check(b);
861
862 CUInt128 result(b ^ a);
863 check ^= a;
864
865 ASSERT_EQUALS(ref, a);
866 ASSERT_EQUALS(check, result);
867 }
aMule P2P client