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         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, AssignCUInt128, wxT("operator=(const CUInt128&)"))
 179 {
 180         CUInt128 a((uint8_t *)&TestData::sequence);
 181         CUInt128 b = a;
 182
 183         ASSERT_EQUALS(a, b);
 184 }
 185
 186 TEST_M(CUInt128, AssignUint32, wxT("operator=(uint32_t)"))
 187 {
 188         CUInt128 a((uint8_t *)&TestData::uintValue);
 189         // Note that CUInt128 b = 0x12345678u; won't work,
 190         // the compiler only allows assignment between the
 191         // same types when constructing the object.
 192         CUInt128 b;
 193         b = 0x12345678u;
 194
 195         ASSERT_EQUALS(a, b);
 196 }
 197
 198 TEST(CUInt128, Set32BitChunk)
 199 {
 200         CUInt128 test;
 201
 202         test.Set32BitChunk(3, 0x12345678u);
 203         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::uintValue), test);
 204
 205         test.Set32BitChunk(0, 0x00010203u);
 206         test.Set32BitChunk(1, 0x04050607u);
 207         test.Set32BitChunk(2, 0x08090a0bu);
 208         test.Set32BitChunk(3, 0x0c0d0e0fu);
 209         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 210 #ifdef __WXDEBUG__
 211         ASSERT_RAISES(CAssertFailureException, test.Set32BitChunk(4, 0));
 212         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 213 #endif
 214
 215         CAssertOff null;
 216         test.Set32BitChunk(4, 0);
 217         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 218 }
 219
 220 TEST_M(CUInt128, SetValueCUInt128, wxT("SetValue(const CUInt128&)"))
 221 {
 222         CUInt128 a((uint8_t *)&TestData::sequence);
 223         CUInt128 b;
 224
 225         b.SetValue(a);
 226         ASSERT_EQUALS(a, b);
 227 }
 228
 229 TEST_M(CUInt128, SetValueUint32, wxT("SetValue(uint32_t)"))
 230 {
 231         CUInt128 a((uint8_t *)&TestData::uintValue);
 232         CUInt128 b;
 233
 234         b.SetValue(0x12345678u);
 235         ASSERT_EQUALS(a, b);
 236 }
 237
 238 TEST(CUInt128, SetValueBE)
 239 {
 240         CUInt128 a((uint8_t *)&TestData::sequence);
 241         CUInt128 b;
 242         uint8_t buffer[16];
 243
 244         a.ToByteArray((uint8_t *)&buffer);
 245         b.SetValueBE((uint8_t *)&buffer);
 246         ASSERT_EQUALS(a, b);
 247 }
 248
 249 TEST(CUInt128, StoreCryptValue)
 250 {
 251         uint8_t ref[16] = { 0x3, 0x2, 0x1, 0x0, 0x7, 0x6, 0x5, 0x4, 0xb, 0xa, 0x9, 0x8, 0xf, 0xe, 0xd, 0xc };
 252         uint8_t tmp[16];
 253         CUInt128 test((uint8_t *)&TestData::sequence);
 254
 255         test.StoreCryptValue((uint8_t *)&tmp);
 256         ASSERT_EQUALS(CUInt128((uint8_t *)&ref), CUInt128((uint8_t *)&tmp));
 257 }
 258
 259 TEST(CUInt128, ShiftLeft)
 260 {
 261         CUInt128 test((uint8_t *)&TestData::one);
 262         uint8_t r1[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 };
 263         uint8_t r2[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 };
 264         uint8_t r3[16] = { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 265         uint8_t r4[16] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 266
 267         test.ShiftLeft(0);
 268         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::one), test);
 269         test.ShiftLeft(1);
 270         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), test);
 271         test.ShiftLeft(32);
 272         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), test);
 273         test.ShiftLeft(58);
 274         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), test);
 275         test.SetValueBE((uint8_t *)&TestData::one);
 276         test.ShiftLeft(127);
 277         ASSERT_EQUALS(CUInt128((uint8_t *)&r4), test);
 278         test.SetValueBE((uint8_t *)&TestData::one);
 279         test.ShiftLeft(128);
 280         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::zero), test);
 281 }
 282
 283 TEST_M(CUInt128, AddCUInt128, wxT("Add(const CUInt128&)"))
 284 {
 285         uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
 286         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 287         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 288         uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 289         uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 290         CUInt128 a((uint8_t *)&TestData::sequence);
 291         CUInt128 d((uint8_t *)&d0);
 292
 293         a.Add(CUInt128(0x01234567u));
 294         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 295         a.Add(CUInt128(0xff000000u));
 296         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 297         a.Add(d);
 298         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
 299         ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
 300         a.Add(d);
 301         ASSERT_EQUALS(CUInt128((uint8_t *)&r4), a);
 302         a.SetValueBE((uint8_t *)&TestData::minusOne);
 303         a.Add(CUInt128((uint8_t *)&TestData::one));
 304         ASSERT_EQUALS(CUInt128(), a);
 305 }
 306
 307 TEST_M(CUInt128, AddUint32, wxT("Add(uint32_t)"))
 308 {
 309         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 310         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 311         CUInt128 a((uint8_t *)&TestData::sequence);
 312
 313         a.Add(0x01234567u);
 314         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 315         a.Add(0xff000000u);
 316         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 317         a.SetValueBE((uint8_t *)&TestData::minusOne);
 318         a.Add(1u);
 319         ASSERT_EQUALS(0, a);
 320 }
 321
 322 TEST_M(CUInt128, SubtractCUInt128, wxT("Subtract(const CUInt128&)"))
 323 {
 324         uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
 325         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 326         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 327         uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 328         uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 329         CUInt128 a((uint8_t *)&r4);
 330         CUInt128 d((uint8_t *)&d0);
 331
 332         a.Subtract(d);
 333         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
 334         ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
 335         a.Subtract(d);
 336         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 337         a.Subtract(CUInt128(0xff000000u));
 338         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 339         a.Subtract(CUInt128(0x01234567u));
 340         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
 341         a.SetValue(0u);
 342         a.Subtract(CUInt128((uint8_t *)&TestData::one));
 343         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
 344 }
 345
 346 TEST_M(CUInt128, SubtractUint32, wxT("Subtract(uint32_t)"))
 347 {
 348         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 349         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 350         CUInt128 a((uint8_t *)&r2);
 351
 352         a.Subtract(0xff000000u);
 353         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 354         a.Subtract(0x01234567u);
 355         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
 356         a.SetValue(0u);
 357         a.Subtract(1u);
 358         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
 359 }
 360
 361 TEST_M(CUInt128, XorCUInt128, wxT("XOR(const CUInt128&)"))
 362 {
 363         uint8_t xd[16] = { 0xff, 0x00, 0xee, 0x11, 0xdd, 0x22, 0xcc, 0x33, 0xbb, 0x44, 0xaa, 0x55, 0x99, 0x66, 0x88, 0x77 };
 364         uint8_t xr[16] = { 0xff, 0x01, 0xec, 0x12, 0xd9, 0x27, 0xca, 0x34, 0xb3, 0x4d, 0xa0, 0x5e, 0x95, 0x6b, 0x86, 0x78 };
 365         CUInt128 a((uint8_t *)&TestData::sequence);
 366         CUInt128 x((uint8_t *)&xd);
 367
 368         a.XOR(x);
 369         ASSERT_EQUALS(CUInt128((uint8_t *)&xr), a);
 370         ASSERT_EQUALS(CUInt128((uint8_t *)&xd), x);
 371 }
 372
 373 // Not yet implemented
 374 #if 0
 375 TEST_M(CUInt128, XorUint32, wxT("XOR(uint32_t)"))
 376 {
 377         CUInt128 a(0x12345678u);
 378
 379         a.XOR(0x76543210u);
 380         ASSERT_EQUALS(0x64606468, a);
 381 }
 382 #endif
 383
 384 TEST_M(CUInt128, OperatorShiftLeftAssign, wxT("operator<<=(unsigned)"))
 385 {
 386         CUInt128 test((uint8_t *)&TestData::one);
 387         uint8_t r1[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 };
 388         uint8_t r2[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 };
 389         uint8_t r3[16] = { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 390         uint8_t r4[16] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 391
 392         test <<= 0;
 393         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::one), test);
 394         test <<= 1;
 395         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), test);
 396         test <<= 32;
 397         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), test);
 398         test <<= 58;
 399         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), test);
 400         test.SetValueBE((uint8_t *)&TestData::one);
 401         test <<= 127;
 402         ASSERT_EQUALS(CUInt128((uint8_t *)&r4), test);
 403         test.SetValueBE((uint8_t *)&TestData::one);
 404         test <<= 128;
 405         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::zero), test);
 406 }
 407
 408 TEST_M(CUInt128, OperatorAddAssignCUInt128, wxT("operator+=(const CUInt128&)"))
 409 {
 410         uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
 411         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 412         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 413         uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 414         uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 415         CUInt128 a((uint8_t *)&TestData::sequence);
 416         CUInt128 d((uint8_t *)&d0);
 417
 418         a += CUInt128(0x01234567u);
 419         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 420         a += CUInt128(0xff000000u);
 421         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 422         a += d;
 423         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
 424         ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
 425         a += d;
 426         ASSERT_EQUALS(CUInt128((uint8_t *)&r4), a);
 427         a.SetValueBE((uint8_t *)&TestData::minusOne);
 428         a += CUInt128((uint8_t *)&TestData::one);
 429         ASSERT_EQUALS(CUInt128(), a);
 430 }
 431
 432 TEST_M(CUInt128, OperatorAddAssignUint32, wxT("operator+=(uint32_t)"))
 433 {
 434         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 435         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 436         CUInt128 a((uint8_t *)&TestData::sequence);
 437
 438         a += 0x01234567u;
 439         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 440         a += 0xff000000u;
 441         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 442         a.SetValueBE((uint8_t *)&TestData::minusOne);
 443         a += 1;
 444         ASSERT_EQUALS(0, a);
 445 }
 446
 447 TEST_M(CUInt128, OperatorSubtractAssignCUInt128, wxT("operator-=(const CUInt128&)"))
 448 {
 449         uint8_t d0[16] = { 0xfc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
 450         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 451         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 452         uint8_t r3[16] = { 0xfc, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 453         uint8_t r4[16] = { 0xf8, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 454         CUInt128 a((uint8_t *)&r4);
 455         CUInt128 d((uint8_t *)&d0);
 456
 457         a -= d;
 458         ASSERT_EQUALS(CUInt128((uint8_t *)&r3), a);
 459         ASSERT_EQUALS(CUInt128((uint8_t *)&d0), d);
 460         a -= d;
 461         ASSERT_EQUALS(CUInt128((uint8_t *)&r2), a);
 462         a -= CUInt128(0xff000000u);
 463         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 464         a -= CUInt128(0x01234567u);
 465         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
 466         a.SetValue(0u);
 467         a -= CUInt128((uint8_t *)&TestData::one);
 468         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
 469 }
 470
 471 TEST_M(CUInt128, OperatorSubtractAssignUint32, wxT("operator-=(uint32_t)"))
 472 {
 473         uint8_t r1[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xd, 0x30, 0x53, 0x76 };
 474         uint8_t r2[16] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xc, 0xc, 0x30, 0x53, 0x76 };
 475         CUInt128 a((uint8_t *)&r2);
 476
 477         a -= 0xff000000u;
 478         ASSERT_EQUALS(CUInt128((uint8_t *)&r1), a);
 479         a -= 0x01234567u;
 480         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), a);
 481         a = 0;
 482         a -= 1;
 483         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::minusOne), a);
 484 }
 485
 486 TEST_M(CUInt128, OperatorXorAssignCUInt128, wxT("operator^=(const CUInt128&)"))
 487 {
 488         uint8_t xd[16] = { 0xff, 0x00, 0xee, 0x11, 0xdd, 0x22, 0xcc, 0x33, 0xbb, 0x44, 0xaa, 0x55, 0x99, 0x66, 0x88, 0x77 };
 489         uint8_t xr[16] = { 0xff, 0x01, 0xec, 0x12, 0xd9, 0x27, 0xca, 0x34, 0xb3, 0x4d, 0xa0, 0x5e, 0x95, 0x6b, 0x86, 0x78 };
 490         CUInt128 a((uint8_t *)&TestData::sequence);
 491         CUInt128 x((uint8_t *)&xd);
 492
 493         a ^= x;
 494         ASSERT_EQUALS(CUInt128((uint8_t *)&xr), a);
 495         ASSERT_EQUALS(CUInt128((uint8_t *)&xd), x);
 496 }
 497
 498 TEST_M(CUInt128, OperatorXorAssignUint32, wxT("operator^=(uint32_t)"))
 499 {
 500         CUInt128 a(0x12345678u);
 501
 502         a ^= 0x76543210u;
 503         ASSERT_EQUALS(0x64606468, a);
 504 }
 505
 506 TEST(CUInt128, GetBitNumber)
 507 {
 508         CUInt128 test;
 509         test = 1;
 510
 511         ASSERT_TRUE(test.GetBitNumber(0) == 0);
 512         ASSERT_TRUE(test.GetBitNumber(127) == 1);
 513         test <<= 127;
 514         ASSERT_TRUE(test.GetBitNumber(0) == 1);
 515         ASSERT_TRUE(test.GetBitNumber(127) == 0);
 516
 517         CUInt128 test2(true);
 518         ASSERT_EQUALS(0u, test2.GetBitNumber(128));
 519 }
 520
 521 TEST(CUInt128, SetBitNumber)
 522 {
 523         CUInt128 test;
 524
 525         test.SetBitNumber(127, 1);
 526         ASSERT_EQUALS(1, test);
 527         test.SetBitNumber(126, 1);
 528         ASSERT_EQUALS(3, test);
 529         test.SetBitNumber(127, 0);
 530         ASSERT_EQUALS(2, test);
 531         test.SetBitNumber(0, 1);
 532         ASSERT_EQUALS(0x80000000u, test.Get32BitChunk(0));
 533 #ifdef __WXDEBUG__
 534         ASSERT_RAISES(CAssertFailureException, test.SetBitNumber(128, 0));
 535 #endif
 536
 537         CAssertOff null;
 538         test.SetValueBE((uint8_t *)&TestData::sequence);
 539         test.SetBitNumber(128, 1);
 540         ASSERT_EQUALS(CUInt128((uint8_t *)&TestData::sequence), test);
 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((uint8_t *)&TestData::sequence);
 717
 718         CUInt128 ref(a);
 719         CUInt128 check(a);
 720
 721         CUInt128 result(a + a);
 722         check.Add(ref);
 723         ASSERT_EQUALS(check, result);
 724         ASSERT_EQUALS(ref, a);
 725
 726         a = ref;
 727         a.SetBitNumber(32, 1);
 728         check = a;
 729         check += a;
 730         result = a + a;
 731         ASSERT_EQUALS(check, result);
 732 }
 733
 734 TEST_M(CUInt128, OperatorSubtractCUInt128, wxT("operator-(const CUInt128&)"))
 735 {
 736         CUInt128 a((uint8_t *)&TestData::randomValue);
 737         CUInt128 b((uint8_t *)&TestData::sequence);
 738
 739         CUInt128 refa(a);
 740         CUInt128 refb(b);
 741         CUInt128 check(a);
 742
 743         CUInt128 result(a - b);
 744         ASSERT_EQUALS(refa, a);
 745         ASSERT_EQUALS(refb, b);
 746         check.Subtract(b);
 747         ASSERT_EQUALS(check, result);
 748
 749         result = b - a;
 750         check = b;
 751         check -= a;
 752         ASSERT_EQUALS(check, result);
 753 }
 754
 755 TEST_M(CUInt128, OperatorXorCUInt128, wxT("operator^(const CUInt128&)"))
 756 {
 757         CUInt128 a((uint8_t *)&TestData::randomValue);
 758         CUInt128 b((uint8_t *)&TestData::sequence);
 759
 760         CUInt128 refa(a);
 761         CUInt128 refb(b);
 762
 763         CUInt128 result(a ^ b);
 764         CUInt128 check(refa);
 765         check ^= refb;
 766
 767         ASSERT_EQUALS(refa, a);
 768         ASSERT_EQUALS(refb, b);
 769         ASSERT_EQUALS(check, result);
 770 }
 771
 772 TEST_M(CUInt128, OperatorAddUint32, wxT("operator+(uint32_t)"))
 773 {
 774         CUInt128 a((uint8_t *)&TestData::randomValue);
 775         uint32_t b = a.Get32BitChunk(0);
 776
 777         CUInt128 ref(a);
 778         CUInt128 check(a);
 779
 780         CUInt128 result(a + b);
 781         check.Add(b);
 782         ASSERT_EQUALS(check, result);
 783         ASSERT_EQUALS(ref, a);
 784
 785         a = ref;
 786         a.SetBitNumber(96, 1);
 787         b = a.Get32BitChunk(3);
 788         check = a;
 789         check += b;
 790         result = a + b;
 791         ASSERT_EQUALS(check, result);
 792 }
 793
 794 TEST_M(CUInt128, OperatorSubtractUint32, wxT("operator-(uint32_t)"))
 795 {
 796         CUInt128 a((uint8_t *)&TestData::randomValue);
 797         uint32_t b = a.Get32BitChunk(0);
 798
 799         CUInt128 ref(a);
 800         CUInt128 check(a);
 801
 802         CUInt128 result(a - b);
 803         ASSERT_EQUALS(ref, a);
 804         check.Subtract(b);
 805         ASSERT_EQUALS(check, result);
 806
 807         result = a - ~b;
 808         check = a;
 809         check -= ~b;
 810         ASSERT_EQUALS(check, result);
 811 }
 812
 813 TEST_M(CUInt128, OperatorXorUint32, wxT("operator^(uint32_t)"))
 814 {
 815         CUInt128 a((uint8_t *)&TestData::randomValue);
 816         uint32_t b = a.Get32BitChunk(0);
 817
 818         CUInt128 ref(a);
 819
 820         CUInt128 result(a ^ b);
 821         CUInt128 check(ref);
 822         check ^= b;
 823
 824         ASSERT_EQUALS(ref, a);
 825         ASSERT_EQUALS(check, result);
 826 }
 827
 828 TEST_M(CUInt128, OperatorAddUint32CUInt128, wxT("operator+(uint32_t, const CUInt128&)"))
 829 {
 830         CUInt128 a((uint8_t *)&TestData::randomValue);
 831         uint32_t b = a.Get32BitChunk(0);
 832
 833         CUInt128 ref(a);
 834         CUInt128 check(b);
 835
 836         CUInt128 result(b + a);
 837         check.Add(a);
 838         ASSERT_EQUALS(check, result);
 839         ASSERT_EQUALS(ref, a);
 840
 841         a = ref;
 842         a.SetBitNumber(96, 1);
 843         b = a.Get32BitChunk(3);
 844         check = b;
 845         check += a;
 846         result = b + a;
 847         ASSERT_EQUALS(check, result);
 848 }
 849
 850 TEST_M(CUInt128, OperatorSubtractUint32CUInt128, wxT("operator-(uint32_t, const CUInt128&)"))
 851 {
 852         CUInt128 a((uint8_t *)&TestData::randomValue);
 853         uint32_t b = a.Get32BitChunk(0);
 854
 855         CUInt128 ref(a);
 856         CUInt128 check(b);
 857
 858         CUInt128 result(b - a);
 859         ASSERT_EQUALS(ref, a);
 860         check.Subtract(a);
 861         ASSERT_EQUALS(check, result);
 862 }
 863
 864 TEST_M(CUInt128, OperatorXorUint32CUInt128, wxT("operator^(uint32_t, const CUInt128&)"))
 865 {
 866         CUInt128 a((uint8_t *)&TestData::randomValue);
 867         uint32_t b = a.Get32BitChunk(0);
 868
 869         CUInt128 ref(a);
 870         CUInt128 check(b);
 871
 872         CUInt128 result(b ^ a);
 873         check ^= a;
 874
 875         ASSERT_EQUALS(ref, a);
 876         ASSERT_EQUALS(check, result);
 877 }