unittests/tests/CUInt128Test.cpp

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