unittests/tests/CUInt128Test.cpp

   1 //                                                              -*- C++ -*-
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2008-2011 Dévai Tamás ( gonosztopi@amule.org )
   5 // Copyright (c) 2008-2011 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         ASSERT_EQUALS(0u, test.Get32BitChunk(4));
 115 }
 116
 117 TEST_M(CUInt128, OperatorEqualsCUInt128, wxT("operator==(const CUInt128&)"))
 118 {
 119         CUInt128 a((uint8_t *)&TestData::sequence);
 120         CUInt128 b((uint8_t *)&TestData::one);
 121
 122         ASSERT_TRUE(a == a);
 123         ASSERT_FALSE(a == b);
 124 }
 125
 126 TEST_M(CUInt128, OperatorEqualsUint32, wxT("operator==(uint32_t)"))
 127 {
 128         ASSERT_TRUE(CUInt128((uint8_t *)&TestData::uintValue) == 0x12345678u);
 129         CUInt128 test((uint8_t *)&TestData::sequence);
 130         ASSERT_FALSE(test == 0x00010203u);
 131         ASSERT_FALSE(test == 0x04050607u);
 132         ASSERT_FALSE(test == 0x08090a0bu);
 133         ASSERT_FALSE(test == 0x0c0d0e0fu);
 134 }
 135
 136 TEST_M(CUInt128, OperatorEqualsUint32CUInt128, wxT("operator==(uint32_t, const CUInt128&)"))
 137 {
 138         ASSERT_TRUE(0x12345678u == CUInt128((uint8_t *)&TestData::uintValue));
 139         CUInt128 test((uint8_t *)&TestData::sequence);
 140         ASSERT_FALSE(0x00010203u == test);
 141         ASSERT_FALSE(0x04050607u == test);
 142         ASSERT_FALSE(0x08090a0bu == test);
 143         ASSERT_FALSE(0x0c0d0e0fu == test);
 144 }
 145
 146 TEST_M(CUInt128, EmptyContructor, wxT("CUInt128()"))
 147 {
 148         CUInt128 test;
 149         CUInt128 ref((uint8_t *)&TestData::zero);
 150
 151         ASSERT_EQUALS(ref, test);
 152 }
 153
 154 TEST_M(CUInt128, CopyConstructor, wxT("CUInt128(const CUInt128&)"))
 155 {
 156         CUInt128 a((uint8_t *)&TestData::sequence);
 157         CUInt128 b(a);
 158
 159         ASSERT_EQUALS(a, b);
 160 }
 161
 162 TEST_M(CUInt128, ConstructFromBool, wxT("CUInt128(bool)"))
 163 {
 164         CUInt128 empty(false);
 165         CUInt128 full(true);
 166         CUInt128 zero((uint8_t *)&TestData::zero);
 167         CUInt128 minusOne((uint8_t *)&TestData::minusOne);
 168
 169         ASSERT_EQUALS(zero, empty);
 170         ASSERT_EQUALS(minusOne, full);
 171 }
 172
 173 TEST_M(CUInt128, ConstructFromUint32, wxT("CUInt128(uint32_t)"))
 174 {
 175         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::uintValue), CUInt128(0x12345678u));
 176 }
 177
 178 TEST_M(CUInt128, ConstructWithBits, wxT("CUInt128(const CUInt128&, unsigned)"))
 179 {
 180         CUInt128 a((uint8_t *)&TestData::sequence);
 181         CUInt128 b((uint8_t *)&TestData::minusOne);
 182
 183         {
 184                 CUInt128 testa(a, 1);
 185                 ASSERT_EQUALS(0u, testa.Get32BitChunk(0) & 0x80000000);
 186
 187                 CUInt128 testb(b, 1);
 188                 ASSERT_EQUALS(0x80000000u, testb.Get32BitChunk(0) & 0x80000000);
 189         }
 190         {
 191                 CUInt128 testa(a, 2);
 192                 ASSERT_EQUALS(0u, testa.Get32BitChunk(0) & 0xc0000000);
 193
 194                 CUInt128 testb(b, 2);
 195                 ASSERT_EQUALS(0xc0000000u, testb.Get32BitChunk(0) & 0xc0000000);
 196         }
 197         {
 198                 CUInt128 testa(a, 8);
 199                 ASSERT_EQUALS(0u, testa.Get32BitChunk(0) & 0xff000000);
 200
 201                 CUInt128 testb(b, 8);
 202                 ASSERT_EQUALS(0xff000000u, testb.Get32BitChunk(0) & 0xff000000);
 203         }
 204         {
 205                 CUInt128 testa(a, 31);
 206                 ASSERT_EQUALS(0x00010202u, testa.Get32BitChunk(0) & 0xfffffffe);
 207
 208                 CUInt128 testb(b, 31);
 209                 ASSERT_EQUALS(0xfffffffeu, testb.Get32BitChunk(0) & 0xfffffffe);
 210         }
 211         {
 212                 CUInt128 testa(a, 32);
 213                 ASSERT_EQUALS(0x00010203u, testa.Get32BitChunk(0));
 214
 215                 CUInt128 testb(b, 32);
 216                 ASSERT_EQUALS(0xffffffffu, testb.Get32BitChunk(0));
 217         }
 218         {
 219                 CUInt128 testa(a, 33);
 220                 ASSERT_EQUALS(0u, testa.Get32BitChunk(1) & 0x80000000);
 221
 222                 CUInt128 testb(b, 33);
 223                 ASSERT_EQUALS(0x80000000u, testb.Get32BitChunk(1) & 0x80000000);
 224         }
 225         {
 226                 CUInt128 testa(a, 128);
 227                 ASSERT_EQUALS(a, testa);
 228
 229                 CUInt128 testb(b, 128);
 230                 ASSERT_EQUALS(b, testb);
 231         }
 232 }
 233
 234 TEST_M(CUInt128, AssignCUInt128, wxT("operator=(const CUInt128&)"))
 235 {
 236         CUInt128 a((uint8_t *)&TestData::sequence);
 237         CUInt128 b = a;
 238
 239         ASSERT_EQUALS(a, b);
 240 }
 241
 242 TEST_M(CUInt128, AssignUint32, wxT("operator=(uint32_t)"))
 243 {
 244         CUInt128 a((uint8_t *)&TestData::uintValue);
 245         // Note that CUInt128 b = 0x12345678u; won't work,
 246         // the compiler only allows assignment between the
 247         // same types when constructing the object.
 248         CUInt128 b;
 249         b = 0x12345678u;
 250
 251         ASSERT_EQUALS(a, b);
 252 }
 253
 254 TEST(CUInt128, Set32BitChunk)
 255 {
 256         CUInt128 test;
 257
 258         test.Set32BitChunk(3, 0x12345678u);
 259         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::uintValue), test);
 260
 261         test.Set32BitChunk(0, 0x00010203u);
 262         test.Set32BitChunk(1, 0x04050607u);
 263         test.Set32BitChunk(2, 0x08090a0bu);
 264         test.Set32BitChunk(3, 0x0c0d0e0fu);
 265         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 266 #ifdef __WXDEBUG__
 267         ASSERT_RAISES(CAssertFailureException, test.Set32BitChunk(4, 0));
 268         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 269 #endif
 270
 271         CAssertOff null;
 272         test.Set32BitChunk(4, 0);
 273         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 274 }
 275
 276 TEST(CUInt128, SetValueBE)
 277 {
 278         CUInt128 a((uint8_t *)&TestData::sequence);
 279         CUInt128 b;
 280         uint8_t buffer[16];
 281
 282         a.ToByteArray((uint8_t *)&buffer);
 283         b.SetValueBE((uint8_t *)&buffer);
 284         ASSERT_EQUALS(a, b);
 285 }
 286
 287 TEST(CUInt128, StoreCryptValue)
 288 {
 289         uint8_t ref[16] = { 0x3, 0x2, 0x1, 0x0, 0x7, 0x6, 0x5, 0x4, 0xb, 0xa, 0x9, 0x8, 0xf, 0xe, 0xd, 0xc };
 290         uint8_t tmp[16];
 291         CUInt128 test((uint8_t *)&TestData::sequence);
 292
 293         test.StoreCryptValue((uint8_t *)&tmp);
 294         ASSERT_EQUALS(CUInt128((uint8_t *)&ref), CUInt128((uint8_t *)&tmp));
 295 }
 296
 297 TEST_M(CUInt128, OperatorShiftLeftAssign, wxT("operator<<=(unsigned)"))
 298 {
 299         CUInt128 test((uint8_t *)&TestData::one);
 300         uint8_t r1[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 };
 301         uint8_t r2[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 };
 302         uint8_t r3[16] = { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 303         uint8_t r4[16] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 304
 305         test <<= 0;
 306         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::one), test);
 307         test <<= 1;
 308         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), test);
 309         test <<= 32;
 310         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), test);
 311         test <<= 58;
 312         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), test);
 313         test.SetValueBE((uint8_t *)&TestData::one);
 314         test <<= 127;
 315         ASSERT_EQUALS(CUInt128((uint8_t *)&r4), test);
 316         test.SetValueBE((uint8_t *)&TestData::one);
 317         test <<= 128;
 318         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::zero), test);
 319 }
 320
 321 TEST_M(CUInt128, OperatorAddAssignCUInt128, wxT("operator+=(const CUInt128&)"))
 322 {
 323         uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
 324         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 325         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 326         uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 327         uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 328         CUInt128 a((uint8_t *)&TestData::sequence);
 329         CUInt128 d((uint8_t *)&d0);
 330
 331         a += CUInt128(0x01234567u);
 332         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 333         a += CUInt128(0xff000000u);
 334         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 335         a += d;
 336         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
 337         ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
 338         a += d;
 339         ASSERT_EQUALS(CUInt128((uint8_t *)&r4), a);
 340         a.SetValueBE((uint8_t *)&TestData::minusOne);
 341         a += CUInt128((uint8_t *)&TestData::one);
 342         ASSERT_EQUALS(CUInt128(), a);
 343 }
 344
 345 TEST_M(CUInt128, OperatorAddAssignUint32, wxT("operator+=(uint32_t)"))
 346 {
 347         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 348         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 349         CUInt128 a((uint8_t *)&TestData::sequence);
 350
 351         a += 0x01234567u;
 352         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 353         a += 0xff000000u;
 354         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 355         a.SetValueBE((uint8_t *)&TestData::minusOne);
 356         a += 1;
 357         ASSERT_EQUALS(0, a);
 358 }
 359
 360 TEST_M(CUInt128, OperatorSubtractAssignCUInt128, wxT("operator-=(const CUInt128&)"))
 361 {
 362         uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
 363         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 364         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 365         uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 366         uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 367         CUInt128 a((uint8_t *)&r4);
 368         CUInt128 d((uint8_t *)&d0);
 369
 370         a -= d;
 371         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
 372         ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
 373         a -= d;
 374         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 375         a -= CUInt128(0xff000000u);
 376         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 377         a -= CUInt128(0x01234567u);
 378         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
 379         a = 0;
 380         a -= CUInt128((uint8_t *)&TestData::one);
 381         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
 382 }
 383
 384 TEST_M(CUInt128, OperatorSubtractAssignUint32, wxT("operator-=(uint32_t)"))
 385 {
 386         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 387         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 388         CUInt128 a((uint8_t *)&r2);
 389
 390         a -= 0xff000000u;
 391         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 392         a -= 0x01234567u;
 393         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
 394         a = 0;
 395         a -= 1;
 396         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
 397 }
 398
 399 TEST_M(CUInt128, OperatorXorAssignCUInt128, wxT("operator^=(const CUInt128&)"))
 400 {
 401         uint8_t xd[16] = { 0xff, 0x00, 0xee, 0x11, 0xdd, 0x22, 0xcc, 0x33, 0xbb, 0x44, 0xaa, 0x55, 0x99, 0x66, 0x88, 0x77 };
 402         uint8_t xr[16] = { 0xff, 0x01, 0xec, 0x12, 0xd9, 0x27, 0xca, 0x34, 0xb3, 0x4d, 0xa0, 0x5e, 0x95, 0x6b, 0x86, 0x78 };
 403         CUInt128 a((uint8_t *)&TestData::sequence);
 404         CUInt128 x((uint8_t *)&xd);
 405
 406         a ^= x;
 407         ASSERT_EQUALS(CUInt128((uint8_t *)&xr), a);
 408         ASSERT_EQUALS(CUInt128((uint8_t *)&xd), x);
 409 }
 410
 411 TEST_M(CUInt128, OperatorXorAssignUint32, wxT("operator^=(uint32_t)"))
 412 {
 413         CUInt128 a(0x12345678u);
 414
 415         a ^= 0x76543210u;
 416         ASSERT_EQUALS(0x64606468, a);
 417 }
 418
 419 TEST(CUInt128, GetBitNumber)
 420 {
 421         CUInt128 test;
 422         test = 1;
 423
 424         ASSERT_TRUE(test.GetBitNumber(0) == 0);
 425         ASSERT_TRUE(test.GetBitNumber(127) == 1);
 426         test <<= 127;
 427         ASSERT_TRUE(test.GetBitNumber(0) == 1);
 428         ASSERT_TRUE(test.GetBitNumber(127) == 0);
 429
 430         CUInt128 test2(true);
 431         ASSERT_EQUALS(0u, test2.GetBitNumber(128));
 432 }
 433
 434 TEST(CUInt128, SetBitNumber)
 435 {
 436         CUInt128 test;
 437
 438         test.SetBitNumber(127, 1);
 439         ASSERT_EQUALS(1, test);
 440         test.SetBitNumber(126, 1);
 441         ASSERT_EQUALS(3, test);
 442         test.SetBitNumber(127, 0);
 443         ASSERT_EQUALS(2, test);
 444         test.SetBitNumber(0, 1);
 445         ASSERT_EQUALS(0x80000000u, test.Get32BitChunk(0));
 446 #ifdef __WXDEBUG__
 447         ASSERT_RAISES(CAssertFailureException, test.SetBitNumber(128, 0));
 448 #endif
 449
 450         CAssertOff null;
 451         test.SetValueBE((uint8_t *)&TestData::sequence);
 452         test.SetBitNumber(128, 1);
 453         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 454 }
 455
 456 TEST_M(CUInt128, OperatorNotEqualCUInt128, wxT("operator!=(const CUInt128&)"))
 457 {
 458         CUInt128 a((uint8_t *)&TestData::sequence);
 459         CUInt128 b((uint8_t *)&TestData::one);
 460
 461         ASSERT_FALSE(a != a);
 462         ASSERT_TRUE(a != b);
 463 }
 464
 465 TEST_M(CUInt128, OperatorNotEqualUint32, wxT("operator!=(uint32_t)"))
 466 {
 467         ASSERT_FALSE(CUInt128((uint8_t *)&TestData::uintValue) != 0x12345678u);
 468         CUInt128 test((uint8_t *)&TestData::sequence);
 469         ASSERT_TRUE(test != 0x00010203u);
 470         ASSERT_TRUE(test != 0x04050607u);
 471         ASSERT_TRUE(test != 0x08090a0bu);
 472         ASSERT_TRUE(test != 0x0c0d0e0fu);
 473 }
 474
 475 TEST_M(CUInt128, OperatorNotEqualUint32CUInt128, wxT("operator!=(uint32_t, const CUInt128&)"))
 476 {
 477         ASSERT_FALSE(0x12345678u != CUInt128((uint8_t *)&TestData::uintValue));
 478         CUInt128 test((uint8_t *)&TestData::sequence);
 479         ASSERT_TRUE(0x00010203u != test);
 480         ASSERT_TRUE(0x04050607u != test);
 481         ASSERT_TRUE(0x08090a0bu != test);
 482         ASSERT_TRUE(0x0c0d0e0fu != test);
 483 }
 484
 485 TEST_M(CUInt128, OperatorLessCUInt128, wxT("operator<(const CUInt128&)"))
 486 {
 487         for (unsigned i = 0; i < 4; i++) {
 488                 CUInt128 a;
 489                 CUInt128 b;
 490                 a.Set32BitChunk(i, 0x0d3859feu);
 491                 b.Set32BitChunk(i, 0xff579ec1u);
 492                 ASSERT_TRUE(a < b);
 493         }
 494 }
 495
 496 TEST_M(CUInt128, OperatorLessOrEqualCUInt128, wxT("operator<=(const CUInt128&)"))
 497 {
 498         for (unsigned i = 0; i < 4; i++) {
 499                 CUInt128 a;
 500                 CUInt128 b;
 501                 a.Set32BitChunk(i, 0x0d3859feu);
 502                 b.Set32BitChunk(i, 0xff579ec1u);
 503                 ASSERT_TRUE(a <= b);
 504                 b.Set32BitChunk(i, a.Get32BitChunk(i));
 505                 ASSERT_TRUE(a <= b);
 506         }
 507 }
 508
 509 TEST_M(CUInt128, OperatorGreaterCUInt128, wxT("operator>(const CUInt128&)"))
 510 {
 511         for (unsigned i = 0; i < 4; i++) {
 512                 CUInt128 a;
 513                 CUInt128 b;
 514                 b.Set32BitChunk(i, 0x0d3859feu);
 515                 a.Set32BitChunk(i, 0xff579ec1u);
 516                 ASSERT_TRUE(a > b);
 517         }
 518 }
 519
 520 TEST_M(CUInt128, OperatorGreaterOrEqualCUInt128, wxT("operator>=(const CUInt128&)"))
 521 {
 522         for (unsigned i = 0; i < 4; i++) {
 523                 CUInt128 a;
 524                 CUInt128 b;
 525                 b.Set32BitChunk(i, 0x0d3859feu);
 526                 a.Set32BitChunk(i, 0xff579ec1u);
 527                 ASSERT_TRUE(a >= b);
 528                 b.Set32BitChunk(i, a.Get32BitChunk(i));
 529                 ASSERT_TRUE(a >= b);
 530         }
 531 }
 532
 533 TEST_M(CUInt128, OperatorLessUint32, wxT("operator<(uint32_t)"))
 534 {
 535         for (unsigned i = 0; i < 4; i++) {
 536                 CUInt128 a;
 537                 a.Set32BitChunk(i, 0x0d3859feu);
 538                 if (i == 3) {
 539                         ASSERT_TRUE(a < 0xffed3216u);
 540                 } else {
 541                         ASSERT_FALSE(a < 0xffed3216u);
 542                 }
 543         }
 544 }
 545
 546 TEST_M(CUInt128, OperatorLessOrEqualUint32, wxT("operator<=(uint32_t)"))
 547 {
 548         for (unsigned i = 0; i < 4; i++) {
 549                 CUInt128 a;
 550                 a.Set32BitChunk(i, 0x0d3859feu);
 551                 if (i == 3) {
 552                         ASSERT_TRUE(a <= 0xffed3216u);
 553                         ASSERT_TRUE(a <= 0x0d3859feu);
 554                 } else {
 555                         ASSERT_FALSE(a <= 0xffed3216u);
 556                         ASSERT_FALSE(a <= 0x0d3859feu);
 557                 }
 558         }
 559 }
 560
 561 TEST_M(CUInt128, OperatorGreaterUint32, wxT("operator>(uint32_t)"))
 562 {
 563         for (unsigned i = 0; i < 4; i++) {
 564                 CUInt128 a;
 565                 a.Set32BitChunk(i, 0xffed3216u);
 566                 ASSERT_TRUE(a > 0x0d3859feu);
 567         }
 568 }
 569
 570 TEST_M(CUInt128, OperatorGreaterOrEqualUint32, wxT("operator>=(uint32_t)"))
 571 {
 572         for (unsigned i = 0; i < 4; i++) {
 573                 CUInt128 a;
 574                 a.Set32BitChunk(i, 0xffed3216u);
 575                 ASSERT_TRUE(a >= 0x0d3859feu);
 576                 ASSERT_TRUE(a >= 0xffed3216u);
 577         }
 578 }
 579
 580 TEST_M(CUInt128, OperatorLessUint32CUInt128, wxT("operator<(uint32_t, const CUInt128&)"))
 581 {
 582         for (unsigned i = 0; i < 4; i++) {
 583                 CUInt128 a;
 584                 a.Set32BitChunk(i, 0xffed3216u);
 585                 ASSERT_TRUE(a > 0x0d3859feu);
 586         }
 587 }
 588
 589 TEST_M(CUInt128, OperatorLessOrEqualUint32CUInt128, wxT("operator<=(uint32_t, const CUInt128&)"))
 590 {
 591         for (unsigned i = 0; i < 4; i++) {
 592                 CUInt128 a;
 593                 a.Set32BitChunk(i, 0xffed3216u);
 594                 ASSERT_TRUE(0x0d3859feu <= a);
 595                 ASSERT_TRUE(0xffed3216u <= a);
 596         }
 597 }
 598
 599 TEST_M(CUInt128, OperatorGreaterUint32CUInt128, wxT("operator>(uint32_t, const CUInt128&)"))
 600 {
 601         for (unsigned i = 0; i < 4; i++) {
 602                 CUInt128 a;
 603                 a.Set32BitChunk(i, 0x0d3859feu);
 604                 if (i == 3) {
 605                         ASSERT_TRUE(0xffed3216u > a);
 606                 } else {
 607                         ASSERT_FALSE(0xffed3216u > a);
 608                 }
 609         }
 610 }
 611
 612 TEST_M(CUInt128, OperatorGreaterOrEqualUint32CUInt128, wxT("operator>=(uint32_t, const CUInt128&)"))
 613 {
 614         for (unsigned i = 0; i < 4; i++) {
 615                 CUInt128 a;
 616                 a.Set32BitChunk(i, 0x0d3859feu);
 617                 if (i == 3) {
 618                         ASSERT_TRUE(0xffed3216u >= a);
 619                         ASSERT_TRUE(0x0d3859feu >= a);
 620                 } else {
 621                         ASSERT_FALSE(0xffed3216u >= a);
 622                         ASSERT_FALSE(0x0d3859feu >= a);
 623                 }
 624         }
 625 }
 626
 627 TEST_M(CUInt128, OperatorAddCUInt128, wxT("operator+(const CUInt128&)"))
 628 {
 629         CUInt128 a((uint8_t *)&TestData::sequence);
 630
 631         CUInt128 ref(a);
 632         CUInt128 check(a);
 633
 634         CUInt128 result(a + a);
 635         check += ref;
 636         ASSERT_EQUALS(check, result);
 637         ASSERT_EQUALS(ref, a);
 638
 639         a = ref;
 640         a.SetBitNumber(32, 1);
 641         check = a;
 642         check += a;
 643         result = a + a;
 644         ASSERT_EQUALS(check, result);
 645 }
 646
 647 TEST_M(CUInt128, OperatorSubtractCUInt128, wxT("operator-(const CUInt128&)"))
 648 {
 649         CUInt128 a((uint8_t *)&TestData::randomValue);
 650         CUInt128 b((uint8_t *)&TestData::sequence);
 651
 652         CUInt128 refa(a);
 653         CUInt128 refb(b);
 654         CUInt128 check(a);
 655
 656         CUInt128 result(a - b);
 657         ASSERT_EQUALS(refa, a);
 658         ASSERT_EQUALS(refb, b);
 659         check -= b;
 660         ASSERT_EQUALS(check, result);
 661
 662         result = b - a;
 663         check = b;
 664         check -= a;
 665         ASSERT_EQUALS(check, result);
 666 }
 667
 668 TEST_M(CUInt128, OperatorXorCUInt128, wxT("operator^(const CUInt128&)"))
 669 {
 670         CUInt128 a((uint8_t *)&TestData::randomValue);
 671         CUInt128 b((uint8_t *)&TestData::sequence);
 672
 673         CUInt128 refa(a);
 674         CUInt128 refb(b);
 675
 676         CUInt128 result(a ^ b);
 677         CUInt128 check(refa);
 678         check ^= refb;
 679
 680         ASSERT_EQUALS(refa, a);
 681         ASSERT_EQUALS(refb, b);
 682         ASSERT_EQUALS(check, result);
 683 }
 684
 685 TEST_M(CUInt128, OperatorAddUint32, wxT("operator+(uint32_t)"))
 686 {
 687         CUInt128 a((uint8_t *)&TestData::randomValue);
 688         uint32_t b = a.Get32BitChunk(0);
 689
 690         CUInt128 ref(a);
 691         CUInt128 check(a);
 692
 693         CUInt128 result(a + b);
 694         check += b;
 695         ASSERT_EQUALS(check, result);
 696         ASSERT_EQUALS(ref, a);
 697
 698         a = ref;
 699         a.SetBitNumber(96, 1);
 700         b = a.Get32BitChunk(3);
 701         check = a;
 702         check += b;
 703         result = a + b;
 704         ASSERT_EQUALS(check, result);
 705 }
 706
 707 TEST_M(CUInt128, OperatorSubtractUint32, wxT("operator-(uint32_t)"))
 708 {
 709         CUInt128 a((uint8_t *)&TestData::randomValue);
 710         uint32_t b = a.Get32BitChunk(0);
 711
 712         CUInt128 ref(a);
 713         CUInt128 check(a);
 714
 715         CUInt128 result(a - b);
 716         ASSERT_EQUALS(ref, a);
 717         check -= b;
 718         ASSERT_EQUALS(check, result);
 719
 720         result = a - ~b;
 721         check = a;
 722         check -= ~b;
 723         ASSERT_EQUALS(check, result);
 724 }
 725
 726 TEST_M(CUInt128, OperatorXorUint32, wxT("operator^(uint32_t)"))
 727 {
 728         CUInt128 a((uint8_t *)&TestData::randomValue);
 729         uint32_t b = a.Get32BitChunk(0);
 730
 731         CUInt128 ref(a);
 732
 733         CUInt128 result(a ^ b);
 734         CUInt128 check(ref);
 735         check ^= b;
 736
 737         ASSERT_EQUALS(ref, a);
 738         ASSERT_EQUALS(check, result);
 739 }
 740
 741 TEST_M(CUInt128, OperatorAddUint32CUInt128, wxT("operator+(uint32_t, const CUInt128&)"))
 742 {
 743         CUInt128 a((uint8_t *)&TestData::randomValue);
 744         uint32_t b = a.Get32BitChunk(0);
 745
 746         CUInt128 ref(a);
 747         CUInt128 check(b);
 748
 749         CUInt128 result(b + a);
 750         check += a;
 751         ASSERT_EQUALS(check, result);
 752         ASSERT_EQUALS(ref, a);
 753
 754         a = ref;
 755         a.SetBitNumber(96, 1);
 756         b = a.Get32BitChunk(3);
 757         check = b;
 758         check += a;
 759         result = b + a;
 760         ASSERT_EQUALS(check, result);
 761 }
 762
 763 TEST_M(CUInt128, OperatorSubtractUint32CUInt128, wxT("operator-(uint32_t, const CUInt128&)"))
 764 {
 765         CUInt128 a((uint8_t *)&TestData::randomValue);
 766         uint32_t b = a.Get32BitChunk(0);
 767
 768         CUInt128 ref(a);
 769         CUInt128 check(b);
 770
 771         CUInt128 result(b - a);
 772         ASSERT_EQUALS(ref, a);
 773         check -= a;
 774         ASSERT_EQUALS(check, result);
 775 }
 776
 777 TEST_M(CUInt128, OperatorXorUint32CUInt128, wxT("operator^(uint32_t, const CUInt128&)"))
 778 {
 779         CUInt128 a((uint8_t *)&TestData::randomValue);
 780         uint32_t b = a.Get32BitChunk(0);
 781
 782         CUInt128 ref(a);
 783         CUInt128 check(b);
 784
 785         CUInt128 result(b ^ a);
 786         check ^= a;
 787
 788         ASSERT_EQUALS(ref, a);
 789         ASSERT_EQUALS(check, result);
 790 }