net/base/int128_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/logging.h"
   7 #include "net/base/int128.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10
  11 TEST(Int128, AllTests) {
  12   uint128 zero(0);
  13   uint128 one(1);
  14   uint128 one_2arg(0, 1);
  15   uint128 two(0, 2);
  16   uint128 three(0, 3);
  17   uint128 big(2000, 2);
  18   uint128 big_minus_one(2000, 1);
  19   uint128 bigger(2001, 1);
  20   uint128 biggest(kuint128max);
  21   uint128 high_low(1, 0);
  22   uint128 low_high(0, kuint64max);
  23   EXPECT_LT(one, two);
  24   EXPECT_GT(two, one);
  25   EXPECT_LT(one, big);
  26   EXPECT_LT(one, big);
  27   EXPECT_EQ(one, one_2arg);
  28   EXPECT_NE(one, two);
  29   EXPECT_GT(big, one);
  30   EXPECT_GE(big, two);
  31   EXPECT_GE(big, big_minus_one);
  32   EXPECT_GT(big, big_minus_one);
  33   EXPECT_LT(big_minus_one, big);
  34   EXPECT_LE(big_minus_one, big);
  35   EXPECT_NE(big_minus_one, big);
  36   EXPECT_LT(big, biggest);
  37   EXPECT_LE(big, biggest);
  38   EXPECT_GT(biggest, big);
  39   EXPECT_GE(biggest, big);
  40   EXPECT_EQ(big, ~~big);
  41   EXPECT_EQ(one, one | one);
  42   EXPECT_EQ(big, big | big);
  43   EXPECT_EQ(one, one | zero);
  44   EXPECT_EQ(one, one & one);
  45   EXPECT_EQ(big, big & big);
  46   EXPECT_EQ(zero, one & zero);
  47   EXPECT_EQ(zero, big & ~big);
  48   EXPECT_EQ(zero, one ^ one);
  49   EXPECT_EQ(zero, big ^ big);
  50   EXPECT_EQ(one, one ^ zero);
  51   EXPECT_EQ(big, big << 0);
  52   EXPECT_EQ(big, big >> 0);
  53   EXPECT_GT(big << 1, big);
  54   EXPECT_LT(big >> 1, big);
  55   EXPECT_EQ(big, (big << 10) >> 10);
  56   EXPECT_EQ(big, (big >> 1) << 1);
  57   EXPECT_EQ(one, (one << 80) >> 80);
  58   EXPECT_EQ(zero, (one >> 80) << 80);
  59   EXPECT_EQ(zero, big >> 128);
  60   EXPECT_EQ(zero, big << 128);
  61   EXPECT_EQ(Uint128High64(biggest), kuint64max);
  62   EXPECT_EQ(Uint128Low64(biggest), kuint64max);
  63   EXPECT_EQ(zero + one, one);
  64   EXPECT_EQ(one + one, two);
  65   EXPECT_EQ(big_minus_one + one, big);
  66   EXPECT_EQ(one - one, zero);
  67   EXPECT_EQ(one - zero, one);
  68   EXPECT_EQ(zero - one, biggest);
  69   EXPECT_EQ(big - big, zero);
  70   EXPECT_EQ(big - one, big_minus_one);
  71   EXPECT_EQ(big + kuint64max, bigger);
  72   EXPECT_EQ(biggest + 1, zero);
  73   EXPECT_EQ(zero - 1, biggest);
  74   EXPECT_EQ(high_low - one, low_high);
  75   EXPECT_EQ(low_high + one, high_low);
  76   EXPECT_EQ(Uint128High64((uint128(1) << 64) - 1), 0u);
  77   EXPECT_EQ(Uint128Low64((uint128(1) << 64) - 1), kuint64max);
  78   EXPECT_TRUE(!!one);
  79   EXPECT_TRUE(!!high_low);
  80   EXPECT_FALSE(!!zero);
  81   EXPECT_FALSE(!one);
  82   EXPECT_FALSE(!high_low);
  83   EXPECT_TRUE(!zero);
  84   EXPECT_TRUE(zero == 0);
  85   EXPECT_FALSE(zero != 0);
  86   EXPECT_FALSE(one == 0);
  87   EXPECT_TRUE(one != 0);
  88
  89   uint128 test = zero;
  90   EXPECT_EQ(++test, one);
  91   EXPECT_EQ(test, one);
  92   EXPECT_EQ(test++, one);
  93   EXPECT_EQ(test, two);
  94   EXPECT_EQ(test -= 2, zero);
  95   EXPECT_EQ(test, zero);
  96   EXPECT_EQ(test += 2, two);
  97   EXPECT_EQ(test, two);
  98   EXPECT_EQ(--test, one);
  99   EXPECT_EQ(test, one);
 100   EXPECT_EQ(test--, one);
 101   EXPECT_EQ(test, zero);
 102   EXPECT_EQ(test |= three, three);
 103   EXPECT_EQ(test &= one, one);
 104   EXPECT_EQ(test ^= three, two);
 105   EXPECT_EQ(test >>= 1, one);
 106   EXPECT_EQ(test <<= 1, two);
 107
 108   EXPECT_EQ(big, -(-big));
 109   EXPECT_EQ(two, -((-one) - 1));
 110   EXPECT_EQ(kuint128max, -one);
 111   EXPECT_EQ(zero, -zero);
 112
 113   LOG(INFO) << one;
 114   LOG(INFO) << big_minus_one;
 115 }
 116
 117 TEST(Int128, PodTests) {
 118   uint128_pod pod = { 12345, 67890 };
 119   uint128 from_pod(pod);
 120   EXPECT_EQ(12345u, Uint128High64(from_pod));
 121   EXPECT_EQ(67890u, Uint128Low64(from_pod));
 122
 123   uint128 zero(0);
 124   uint128_pod zero_pod = {0, 0};
 125   uint128 one(1);
 126   uint128_pod one_pod = {0, 1};
 127   uint128 two(2);
 128   uint128_pod two_pod = {0, 2};
 129   uint128 three(3);
 130   uint128_pod three_pod = {0, 3};
 131   uint128 big(1, 0);
 132   uint128_pod big_pod = {1, 0};
 133
 134   EXPECT_EQ(zero, zero_pod);
 135   EXPECT_EQ(zero_pod, zero);
 136   EXPECT_EQ(zero_pod, zero_pod);
 137   EXPECT_EQ(one, one_pod);
 138   EXPECT_EQ(one_pod, one);
 139   EXPECT_EQ(one_pod, one_pod);
 140   EXPECT_EQ(two, two_pod);
 141   EXPECT_EQ(two_pod, two);
 142   EXPECT_EQ(two_pod, two_pod);
 143
 144   EXPECT_NE(one, two_pod);
 145   EXPECT_NE(one_pod, two);
 146   EXPECT_NE(one_pod, two_pod);
 147
 148   EXPECT_LT(one, two_pod);
 149   EXPECT_LT(one_pod, two);
 150   EXPECT_LT(one_pod, two_pod);
 151   EXPECT_LE(one, one_pod);
 152   EXPECT_LE(one_pod, one);
 153   EXPECT_LE(one_pod, one_pod);
 154   EXPECT_LE(one, two_pod);
 155   EXPECT_LE(one_pod, two);
 156   EXPECT_LE(one_pod, two_pod);
 157
 158   EXPECT_GT(two, one_pod);
 159   EXPECT_GT(two_pod, one);
 160   EXPECT_GT(two_pod, one_pod);
 161   EXPECT_GE(two, two_pod);
 162   EXPECT_GE(two_pod, two);
 163   EXPECT_GE(two_pod, two_pod);
 164   EXPECT_GE(two, one_pod);
 165   EXPECT_GE(two_pod, one);
 166   EXPECT_GE(two_pod, one_pod);
 167
 168   EXPECT_EQ(three, one | two_pod);
 169   EXPECT_EQ(three, one_pod | two);
 170   EXPECT_EQ(three, one_pod | two_pod);
 171   EXPECT_EQ(one, three & one_pod);
 172   EXPECT_EQ(one, three_pod & one);
 173   EXPECT_EQ(one, three_pod & one_pod);
 174   EXPECT_EQ(two, three ^ one_pod);
 175   EXPECT_EQ(two, three_pod ^ one);
 176   EXPECT_EQ(two, three_pod ^ one_pod);
 177   EXPECT_EQ(two, three & (~one));
 178   EXPECT_EQ(three, ~~three);
 179
 180   EXPECT_EQ(two, two_pod << 0);
 181   EXPECT_EQ(two, one_pod << 1);
 182   EXPECT_EQ(big, one_pod << 64);
 183   EXPECT_EQ(zero, one_pod << 128);
 184   EXPECT_EQ(two, two_pod >> 0);
 185   EXPECT_EQ(one, two_pod >> 1);
 186   EXPECT_EQ(one, big_pod >> 64);
 187
 188   EXPECT_EQ(one, zero + one_pod);
 189   EXPECT_EQ(one, zero_pod + one);
 190   EXPECT_EQ(one, zero_pod + one_pod);
 191   EXPECT_EQ(one, two - one_pod);
 192   EXPECT_EQ(one, two_pod - one);
 193   EXPECT_EQ(one, two_pod - one_pod);
 194 }
 195
 196 TEST(Int128, OperatorAssignReturnRef) {
 197   uint128 v(1);
 198   (v += 4) -= 3;
 199   EXPECT_EQ(2, v);
 200 }
 201
 202 TEST(Int128, Multiply) {
 203   uint128 a, b, c;
 204
 205   // Zero test.
 206   a = 0;
 207   b = 0;
 208   c = a * b;
 209   EXPECT_EQ(0, c);
 210
 211   // Max carries.
 212   a = uint128(0) - 1;
 213   b = uint128(0) - 1;
 214   c = a * b;
 215   EXPECT_EQ(1, c);
 216
 217   // Self-operation with max carries.
 218   c = uint128(0) - 1;
 219   c *= c;
 220   EXPECT_EQ(1, c);
 221
 222   // 1-bit x 1-bit.
 223   for (int i = 0; i < 64; ++i) {
 224     for (int j = 0; j < 64; ++j) {
 225       a = uint128(1) << i;
 226       b = uint128(1) << j;
 227       c = a * b;
 228       EXPECT_EQ(uint128(1) << (i+j), c);
 229     }
 230   }
 231
 232   // Verified with dc.
 233   a = uint128(GG_ULONGLONG(0xffffeeeeddddcccc),
 234               GG_ULONGLONG(0xbbbbaaaa99998888));
 235   b = uint128(GG_ULONGLONG(0x7777666655554444),
 236               GG_ULONGLONG(0x3333222211110000));
 237   c = a * b;
 238   EXPECT_EQ(uint128(GG_ULONGLONG(0x530EDA741C71D4C3),
 239                     GG_ULONGLONG(0xBF25975319080000)), c);
 240   EXPECT_EQ(0, c - b * a);
 241   EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
 242
 243   // Verified with dc.
 244   a = uint128(GG_ULONGLONG(0x0123456789abcdef),
 245               GG_ULONGLONG(0xfedcba9876543210));
 246   b = uint128(GG_ULONGLONG(0x02468ace13579bdf),
 247               GG_ULONGLONG(0xfdb97531eca86420));
 248   c = a * b;
 249   EXPECT_EQ(uint128(GG_ULONGLONG(0x97a87f4f261ba3f2),
 250                     GG_ULONGLONG(0x342d0bbf48948200)), c);
 251   EXPECT_EQ(0, c - b * a);
 252   EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
 253 }
 254
 255 TEST(Int128, AliasTests) {
 256   uint128 x1(1, 2);
 257   uint128 x2(2, 4);
 258   x1 += x1;
 259   EXPECT_EQ(x2, x1);
 260
 261   uint128 x3(1, 1ull << 63);
 262   uint128 x4(3, 0);
 263   x3 += x3;
 264   EXPECT_EQ(x4, x3);
 265 }