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 } 266
