1 // Copyright 2018 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/base/uint128.h"
16
17 #include <gtest/gtest.h>
18
19 namespace astc_codec {
20 namespace base {
21
TEST(UInt128,Equality)22 TEST(UInt128, Equality) {
23 const UInt128 zero(0);
24 const UInt128 max64(~0ULL);
25
26 EXPECT_EQ(zero, zero);
27 EXPECT_NE(zero, max64);
28 EXPECT_EQ(zero, UInt128(0));
29 EXPECT_NE(zero, UInt128(1));
30 EXPECT_EQ(max64, max64);
31 }
32
TEST(UInt128,Shifting)33 TEST(UInt128, Shifting) {
34 const UInt128 max64(~0ULL);
35 const UInt128 upper64(~0ULL, 0);
36 EXPECT_EQ(upper64.HighBits(), ~0ULL);
37 EXPECT_EQ(upper64.LowBits(), 0);
38
39 EXPECT_EQ(upper64 >> 64, max64);
40
41 EXPECT_EQ(UInt128(1) << 1, UInt128(2));
42 EXPECT_EQ(UInt128(0) << 0, UInt128(0));
43 EXPECT_EQ(max64 << 0, max64);
44 EXPECT_EQ(max64 >> 0, max64);
45 EXPECT_EQ(upper64 << 0, upper64);
46 EXPECT_EQ(upper64 >> 0, upper64);
47
48 {
49 const UInt128 bit63 = UInt128(1ULL << 62) << 1;
50 EXPECT_EQ(bit63.LowBits(), 1ULL << 63);
51 EXPECT_EQ(bit63.HighBits(), 0);
52 }
53
54 {
55 const UInt128 bit64 = UInt128(1ULL << 63) << 1;
56 EXPECT_EQ(bit64.LowBits(), 0);
57 EXPECT_EQ(bit64.HighBits(), 1);
58 EXPECT_EQ(bit64 >> 1, UInt128(1ULL << 63));
59 }
60
61 {
62 const UInt128 overshift = max64 << 128;
63 EXPECT_EQ(overshift.HighBits(), 0);
64 EXPECT_EQ(overshift.LowBits(), 0);
65 }
66
67 {
68 const UInt128 overlap = upper64 >> 32;
69 EXPECT_EQ(overlap.HighBits(), 0x00000000FFFFFFFF);
70 EXPECT_EQ(overlap.LowBits(), 0xFFFFFFFF00000000);
71 }
72
73 {
74 const UInt128 overlap = max64 << 32;
75 EXPECT_EQ(overlap.HighBits(), 0x00000000FFFFFFFF);
76 EXPECT_EQ(overlap.LowBits(), 0xFFFFFFFF00000000);
77 }
78 }
79
TEST(UInt128,LargeShift)80 TEST(UInt128, LargeShift) {
81 const UInt128 base(0xFF);
82 EXPECT_EQ(base << 64, UInt128(0xFFULL, 0));
83 EXPECT_EQ(base << 72, UInt128(0xFF00ULL, 0));
84 EXPECT_EQ(base << 80, UInt128(0xFF0000ULL, 0));
85 EXPECT_EQ(base << 88, UInt128(0xFF000000ULL, 0));
86 EXPECT_EQ(base << 96, UInt128(0xFF00000000ULL, 0));
87 EXPECT_EQ(base << 104, UInt128(0xFF0000000000ULL, 0));
88 EXPECT_EQ(base << 112, UInt128(0xFF000000000000ULL, 0));
89 EXPECT_EQ(base << 120, UInt128(0xFF00000000000000ULL, 0));
90
91 const UInt128 upper(0xFF00000000000000ULL, 0);
92 EXPECT_EQ(upper >> 64, UInt128(0, 0xFF00000000000000ULL));
93 EXPECT_EQ(upper >> 72, UInt128(0, 0xFF000000000000ULL));
94 EXPECT_EQ(upper >> 80, UInt128(0, 0xFF0000000000ULL));
95 EXPECT_EQ(upper >> 88, UInt128(0, 0xFF00000000ULL));
96 EXPECT_EQ(upper >> 96, UInt128(0, 0xFF000000ULL));
97 EXPECT_EQ(upper >> 104, UInt128(0, 0xFF0000ULL));
98 EXPECT_EQ(upper >> 112, UInt128(0, 0xFF00ULL));
99 EXPECT_EQ(upper >> 120, UInt128(0, 0xFFULL));
100 }
101
TEST(UInt128,BooleanOperators)102 TEST(UInt128, BooleanOperators) {
103 const UInt128 allOnes(~0ULL, ~0ULL);
104 EXPECT_EQ(allOnes.HighBits(), ~0ULL);
105 EXPECT_EQ(allOnes.LowBits(), ~0ULL);
106
107 EXPECT_EQ(~allOnes, UInt128(0));
108 EXPECT_EQ(~UInt128(0), allOnes);
109
110 EXPECT_EQ(UInt128(0xFFFF00) & UInt128(0x00FFFF), UInt128(0x00FF00));
111 EXPECT_EQ(UInt128(0xFFFF00) | UInt128(0x00FFFF), UInt128(0xFFFFFF));
112 EXPECT_EQ(UInt128(0xFFFF00) ^ UInt128(0x00FFFF), UInt128(0xFF00FF));
113 }
114
TEST(UInt128,Addition)115 TEST(UInt128, Addition) {
116 const UInt128 bit63(1ULL << 63);
117
118 EXPECT_EQ(UInt128(1) + 1, UInt128(2));
119 EXPECT_EQ(bit63 + bit63, UInt128(1) << 64);
120
121 const UInt128 carryUp = UInt128(~0ULL) + 1;
122 EXPECT_EQ(carryUp.HighBits(), 1);
123 EXPECT_EQ(carryUp.LowBits(), 0);
124
125 const UInt128 allOnes(~0ULL, ~0ULL);
126 EXPECT_EQ(allOnes + 1, UInt128(0));
127 }
128
TEST(UInt128,Subtraction)129 TEST(UInt128, Subtraction) {
130 const UInt128 bit64 = UInt128(1) << 64;
131 EXPECT_EQ(bit64 - 1, UInt128(~0ULL));
132
133 EXPECT_EQ(UInt128(1) - 1, UInt128(0));
134
135 const UInt128 allOnes(~0ULL, ~0ULL);
136 EXPECT_EQ(UInt128(0) - 1, allOnes);
137 }
138
139 } // namespace base
140 } // namespace astc_codec
141