OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
| 5 #include "platform/utils.h" |
5 #include "platform/assert.h" | 6 #include "platform/assert.h" |
6 #include "platform/utils.h" | |
7 #include "vm/unit_test.h" | 7 #include "vm/unit_test.h" |
8 | 8 |
9 namespace dart { | 9 namespace dart { |
10 | 10 |
11 VM_UNIT_TEST_CASE(Minimum) { | 11 VM_UNIT_TEST_CASE(Minimum) { |
12 EXPECT_EQ(0, Utils::Minimum(0, 1)); | 12 EXPECT_EQ(0, Utils::Minimum(0, 1)); |
13 EXPECT_EQ(0, Utils::Minimum(1, 0)); | 13 EXPECT_EQ(0, Utils::Minimum(1, 0)); |
14 | 14 |
15 EXPECT_EQ(1, Utils::Minimum(1, 2)); | 15 EXPECT_EQ(1, Utils::Minimum(1, 2)); |
16 EXPECT_EQ(1, Utils::Minimum(2, 1)); | 16 EXPECT_EQ(1, Utils::Minimum(2, 1)); |
17 | 17 |
18 EXPECT_EQ(-1, Utils::Minimum(-1, 1)); | 18 EXPECT_EQ(-1, Utils::Minimum(-1, 1)); |
19 EXPECT_EQ(-1, Utils::Minimum(1, -1)); | 19 EXPECT_EQ(-1, Utils::Minimum(1, -1)); |
20 | 20 |
21 EXPECT_EQ(-2, Utils::Minimum(-1, -2)); | 21 EXPECT_EQ(-2, Utils::Minimum(-1, -2)); |
22 EXPECT_EQ(-2, Utils::Minimum(-2, -1)); | 22 EXPECT_EQ(-2, Utils::Minimum(-2, -1)); |
23 } | 23 } |
24 | 24 |
25 | |
26 VM_UNIT_TEST_CASE(Maximum) { | 25 VM_UNIT_TEST_CASE(Maximum) { |
27 EXPECT_EQ(1, Utils::Maximum(0, 1)); | 26 EXPECT_EQ(1, Utils::Maximum(0, 1)); |
28 EXPECT_EQ(1, Utils::Maximum(1, 0)); | 27 EXPECT_EQ(1, Utils::Maximum(1, 0)); |
29 | 28 |
30 EXPECT_EQ(2, Utils::Maximum(1, 2)); | 29 EXPECT_EQ(2, Utils::Maximum(1, 2)); |
31 EXPECT_EQ(2, Utils::Maximum(2, 1)); | 30 EXPECT_EQ(2, Utils::Maximum(2, 1)); |
32 | 31 |
33 EXPECT_EQ(1, Utils::Maximum(-1, 1)); | 32 EXPECT_EQ(1, Utils::Maximum(-1, 1)); |
34 EXPECT_EQ(1, Utils::Maximum(1, -1)); | 33 EXPECT_EQ(1, Utils::Maximum(1, -1)); |
35 | 34 |
36 EXPECT_EQ(-1, Utils::Maximum(-1, -2)); | 35 EXPECT_EQ(-1, Utils::Maximum(-1, -2)); |
37 EXPECT_EQ(-1, Utils::Maximum(-2, -1)); | 36 EXPECT_EQ(-1, Utils::Maximum(-2, -1)); |
38 } | 37 } |
39 | 38 |
40 | |
41 VM_UNIT_TEST_CASE(IsPowerOfTwo) { | 39 VM_UNIT_TEST_CASE(IsPowerOfTwo) { |
42 EXPECT(!Utils::IsPowerOfTwo(0)); | 40 EXPECT(!Utils::IsPowerOfTwo(0)); |
43 EXPECT(Utils::IsPowerOfTwo(1)); | 41 EXPECT(Utils::IsPowerOfTwo(1)); |
44 EXPECT(Utils::IsPowerOfTwo(2)); | 42 EXPECT(Utils::IsPowerOfTwo(2)); |
45 EXPECT(!Utils::IsPowerOfTwo(3)); | 43 EXPECT(!Utils::IsPowerOfTwo(3)); |
46 EXPECT(Utils::IsPowerOfTwo(4)); | 44 EXPECT(Utils::IsPowerOfTwo(4)); |
47 EXPECT(Utils::IsPowerOfTwo(256)); | 45 EXPECT(Utils::IsPowerOfTwo(256)); |
48 | 46 |
49 EXPECT(!Utils::IsPowerOfTwo(-1)); | 47 EXPECT(!Utils::IsPowerOfTwo(-1)); |
50 EXPECT(!Utils::IsPowerOfTwo(-2)); | 48 EXPECT(!Utils::IsPowerOfTwo(-2)); |
51 } | 49 } |
52 | 50 |
53 | |
54 VM_UNIT_TEST_CASE(ShiftForPowerOfTwo) { | 51 VM_UNIT_TEST_CASE(ShiftForPowerOfTwo) { |
55 EXPECT_EQ(1, Utils::ShiftForPowerOfTwo(2)); | 52 EXPECT_EQ(1, Utils::ShiftForPowerOfTwo(2)); |
56 EXPECT_EQ(2, Utils::ShiftForPowerOfTwo(4)); | 53 EXPECT_EQ(2, Utils::ShiftForPowerOfTwo(4)); |
57 EXPECT_EQ(8, Utils::ShiftForPowerOfTwo(256)); | 54 EXPECT_EQ(8, Utils::ShiftForPowerOfTwo(256)); |
58 } | 55 } |
59 | 56 |
60 | |
61 VM_UNIT_TEST_CASE(IsAligned) { | 57 VM_UNIT_TEST_CASE(IsAligned) { |
62 EXPECT(Utils::IsAligned(0, 1)); | 58 EXPECT(Utils::IsAligned(0, 1)); |
63 EXPECT(Utils::IsAligned(1, 1)); | 59 EXPECT(Utils::IsAligned(1, 1)); |
64 | 60 |
65 EXPECT(Utils::IsAligned(0, 2)); | 61 EXPECT(Utils::IsAligned(0, 2)); |
66 EXPECT(!Utils::IsAligned(1, 2)); | 62 EXPECT(!Utils::IsAligned(1, 2)); |
67 EXPECT(Utils::IsAligned(2, 2)); | 63 EXPECT(Utils::IsAligned(2, 2)); |
68 | 64 |
69 EXPECT(Utils::IsAligned(32, 8)); | 65 EXPECT(Utils::IsAligned(32, 8)); |
70 EXPECT(!Utils::IsAligned(33, 8)); | 66 EXPECT(!Utils::IsAligned(33, 8)); |
71 EXPECT(Utils::IsAligned(40, 8)); | 67 EXPECT(Utils::IsAligned(40, 8)); |
72 } | 68 } |
73 | 69 |
74 | |
75 VM_UNIT_TEST_CASE(RoundDown) { | 70 VM_UNIT_TEST_CASE(RoundDown) { |
76 EXPECT_EQ(0, Utils::RoundDown(22, 32)); | 71 EXPECT_EQ(0, Utils::RoundDown(22, 32)); |
77 EXPECT_EQ(32, Utils::RoundDown(33, 32)); | 72 EXPECT_EQ(32, Utils::RoundDown(33, 32)); |
78 EXPECT_EQ(32, Utils::RoundDown(63, 32)); | 73 EXPECT_EQ(32, Utils::RoundDown(63, 32)); |
79 uword* address = reinterpret_cast<uword*>(63); | 74 uword* address = reinterpret_cast<uword*>(63); |
80 uword* rounddown_address = reinterpret_cast<uword*>(32); | 75 uword* rounddown_address = reinterpret_cast<uword*>(32); |
81 EXPECT_EQ(rounddown_address, Utils::RoundDown(address, 32)); | 76 EXPECT_EQ(rounddown_address, Utils::RoundDown(address, 32)); |
82 } | 77 } |
83 | 78 |
84 | |
85 VM_UNIT_TEST_CASE(RoundUp) { | 79 VM_UNIT_TEST_CASE(RoundUp) { |
86 EXPECT_EQ(32, Utils::RoundUp(22, 32)); | 80 EXPECT_EQ(32, Utils::RoundUp(22, 32)); |
87 EXPECT_EQ(64, Utils::RoundUp(33, 32)); | 81 EXPECT_EQ(64, Utils::RoundUp(33, 32)); |
88 EXPECT_EQ(64, Utils::RoundUp(63, 32)); | 82 EXPECT_EQ(64, Utils::RoundUp(63, 32)); |
89 uword* address = reinterpret_cast<uword*>(63); | 83 uword* address = reinterpret_cast<uword*>(63); |
90 uword* roundup_address = reinterpret_cast<uword*>(64); | 84 uword* roundup_address = reinterpret_cast<uword*>(64); |
91 EXPECT_EQ(roundup_address, Utils::RoundUp(address, 32)); | 85 EXPECT_EQ(roundup_address, Utils::RoundUp(address, 32)); |
92 } | 86 } |
93 | 87 |
94 | |
95 VM_UNIT_TEST_CASE(RoundUpToPowerOfTwo) { | 88 VM_UNIT_TEST_CASE(RoundUpToPowerOfTwo) { |
96 EXPECT_EQ(0U, Utils::RoundUpToPowerOfTwo(0)); | 89 EXPECT_EQ(0U, Utils::RoundUpToPowerOfTwo(0)); |
97 EXPECT_EQ(1U, Utils::RoundUpToPowerOfTwo(1)); | 90 EXPECT_EQ(1U, Utils::RoundUpToPowerOfTwo(1)); |
98 EXPECT_EQ(2U, Utils::RoundUpToPowerOfTwo(2)); | 91 EXPECT_EQ(2U, Utils::RoundUpToPowerOfTwo(2)); |
99 EXPECT_EQ(4U, Utils::RoundUpToPowerOfTwo(3)); | 92 EXPECT_EQ(4U, Utils::RoundUpToPowerOfTwo(3)); |
100 EXPECT_EQ(4U, Utils::RoundUpToPowerOfTwo(4)); | 93 EXPECT_EQ(4U, Utils::RoundUpToPowerOfTwo(4)); |
101 EXPECT_EQ(8U, Utils::RoundUpToPowerOfTwo(5)); | 94 EXPECT_EQ(8U, Utils::RoundUpToPowerOfTwo(5)); |
102 EXPECT_EQ(8U, Utils::RoundUpToPowerOfTwo(7)); | 95 EXPECT_EQ(8U, Utils::RoundUpToPowerOfTwo(7)); |
103 EXPECT_EQ(16U, Utils::RoundUpToPowerOfTwo(9)); | 96 EXPECT_EQ(16U, Utils::RoundUpToPowerOfTwo(9)); |
104 EXPECT_EQ(16U, Utils::RoundUpToPowerOfTwo(16)); | 97 EXPECT_EQ(16U, Utils::RoundUpToPowerOfTwo(16)); |
105 EXPECT_EQ(0x10000000U, Utils::RoundUpToPowerOfTwo(0x08765432)); | 98 EXPECT_EQ(0x10000000U, Utils::RoundUpToPowerOfTwo(0x08765432)); |
106 } | 99 } |
107 | 100 |
108 | |
109 VM_UNIT_TEST_CASE(CountOneBits) { | 101 VM_UNIT_TEST_CASE(CountOneBits) { |
110 EXPECT_EQ(0, Utils::CountOneBits(0)); | 102 EXPECT_EQ(0, Utils::CountOneBits(0)); |
111 EXPECT_EQ(1, Utils::CountOneBits(0x00000010)); | 103 EXPECT_EQ(1, Utils::CountOneBits(0x00000010)); |
112 EXPECT_EQ(1, Utils::CountOneBits(0x00010000)); | 104 EXPECT_EQ(1, Utils::CountOneBits(0x00010000)); |
113 EXPECT_EQ(1, Utils::CountOneBits(0x10000000)); | 105 EXPECT_EQ(1, Utils::CountOneBits(0x10000000)); |
114 EXPECT_EQ(4, Utils::CountOneBits(0x10101010)); | 106 EXPECT_EQ(4, Utils::CountOneBits(0x10101010)); |
115 EXPECT_EQ(8, Utils::CountOneBits(0x03030303)); | 107 EXPECT_EQ(8, Utils::CountOneBits(0x03030303)); |
116 EXPECT_EQ(32, Utils::CountOneBits(0xFFFFFFFF)); | 108 EXPECT_EQ(32, Utils::CountOneBits(0xFFFFFFFF)); |
117 } | 109 } |
118 | 110 |
119 | |
120 VM_UNIT_TEST_CASE(CountZeros) { | 111 VM_UNIT_TEST_CASE(CountZeros) { |
121 EXPECT_EQ(0, Utils::CountTrailingZeros(0x1)); | 112 EXPECT_EQ(0, Utils::CountTrailingZeros(0x1)); |
122 EXPECT_EQ(kBitsPerWord - 1, Utils::CountLeadingZeros(0x1)); | 113 EXPECT_EQ(kBitsPerWord - 1, Utils::CountLeadingZeros(0x1)); |
123 EXPECT_EQ(1, Utils::CountTrailingZeros(0x2)); | 114 EXPECT_EQ(1, Utils::CountTrailingZeros(0x2)); |
124 EXPECT_EQ(kBitsPerWord - 2, Utils::CountLeadingZeros(0x2)); | 115 EXPECT_EQ(kBitsPerWord - 2, Utils::CountLeadingZeros(0x2)); |
125 EXPECT_EQ(0, Utils::CountTrailingZeros(0x3)); | 116 EXPECT_EQ(0, Utils::CountTrailingZeros(0x3)); |
126 EXPECT_EQ(kBitsPerWord - 2, Utils::CountLeadingZeros(0x3)); | 117 EXPECT_EQ(kBitsPerWord - 2, Utils::CountLeadingZeros(0x3)); |
127 EXPECT_EQ(2, Utils::CountTrailingZeros(0x4)); | 118 EXPECT_EQ(2, Utils::CountTrailingZeros(0x4)); |
128 EXPECT_EQ(kBitsPerWord - 3, Utils::CountLeadingZeros(0x4)); | 119 EXPECT_EQ(kBitsPerWord - 3, Utils::CountLeadingZeros(0x4)); |
129 EXPECT_EQ(0, Utils::CountTrailingZeros(kUwordMax)); | 120 EXPECT_EQ(0, Utils::CountTrailingZeros(kUwordMax)); |
130 EXPECT_EQ(0, Utils::CountLeadingZeros(kUwordMax)); | 121 EXPECT_EQ(0, Utils::CountLeadingZeros(kUwordMax)); |
131 static const uword kTopBit = static_cast<uword>(1) << (kBitsPerWord - 1); | 122 static const uword kTopBit = static_cast<uword>(1) << (kBitsPerWord - 1); |
132 EXPECT_EQ(kBitsPerWord - 1, Utils::CountTrailingZeros(kTopBit)); | 123 EXPECT_EQ(kBitsPerWord - 1, Utils::CountTrailingZeros(kTopBit)); |
133 EXPECT_EQ(0, Utils::CountLeadingZeros(kTopBit)); | 124 EXPECT_EQ(0, Utils::CountLeadingZeros(kTopBit)); |
134 } | 125 } |
135 | 126 |
136 | |
137 VM_UNIT_TEST_CASE(IsInt) { | 127 VM_UNIT_TEST_CASE(IsInt) { |
138 EXPECT(Utils::IsInt(8, 16)); | 128 EXPECT(Utils::IsInt(8, 16)); |
139 EXPECT(Utils::IsInt(8, 127)); | 129 EXPECT(Utils::IsInt(8, 127)); |
140 EXPECT(Utils::IsInt(8, -128)); | 130 EXPECT(Utils::IsInt(8, -128)); |
141 EXPECT(!Utils::IsInt(8, 255)); | 131 EXPECT(!Utils::IsInt(8, 255)); |
142 EXPECT(Utils::IsInt(16, 16)); | 132 EXPECT(Utils::IsInt(16, 16)); |
143 EXPECT(!Utils::IsInt(16, 65535)); | 133 EXPECT(!Utils::IsInt(16, 65535)); |
144 EXPECT(Utils::IsInt(16, 32767)); | 134 EXPECT(Utils::IsInt(16, 32767)); |
145 EXPECT(Utils::IsInt(16, -32768)); | 135 EXPECT(Utils::IsInt(16, -32768)); |
146 EXPECT(Utils::IsInt(32, 16LL)); | 136 EXPECT(Utils::IsInt(32, 16LL)); |
147 EXPECT(Utils::IsInt(32, 2147483647LL)); | 137 EXPECT(Utils::IsInt(32, 2147483647LL)); |
148 EXPECT(Utils::IsInt(32, -2147483648LL)); | 138 EXPECT(Utils::IsInt(32, -2147483648LL)); |
149 EXPECT(!Utils::IsInt(32, 4294967295LL)); | 139 EXPECT(!Utils::IsInt(32, 4294967295LL)); |
150 } | 140 } |
151 | 141 |
152 | |
153 VM_UNIT_TEST_CASE(IsUint) { | 142 VM_UNIT_TEST_CASE(IsUint) { |
154 EXPECT(Utils::IsUint(8, 16)); | 143 EXPECT(Utils::IsUint(8, 16)); |
155 EXPECT(Utils::IsUint(8, 0)); | 144 EXPECT(Utils::IsUint(8, 0)); |
156 EXPECT(Utils::IsUint(8, 255)); | 145 EXPECT(Utils::IsUint(8, 255)); |
157 EXPECT(!Utils::IsUint(8, 256)); | 146 EXPECT(!Utils::IsUint(8, 256)); |
158 EXPECT(Utils::IsUint(16, 16)); | 147 EXPECT(Utils::IsUint(16, 16)); |
159 EXPECT(Utils::IsUint(16, 0)); | 148 EXPECT(Utils::IsUint(16, 0)); |
160 EXPECT(Utils::IsUint(16, 65535)); | 149 EXPECT(Utils::IsUint(16, 65535)); |
161 EXPECT(!Utils::IsUint(16, 65536)); | 150 EXPECT(!Utils::IsUint(16, 65536)); |
162 EXPECT(Utils::IsUint(32, 16LL)); | 151 EXPECT(Utils::IsUint(32, 16LL)); |
163 EXPECT(Utils::IsUint(32, 0LL)); | 152 EXPECT(Utils::IsUint(32, 0LL)); |
164 EXPECT(Utils::IsUint(32, 4294967295LL)); | 153 EXPECT(Utils::IsUint(32, 4294967295LL)); |
165 EXPECT(!Utils::IsUint(32, 4294967296LL)); | 154 EXPECT(!Utils::IsUint(32, 4294967296LL)); |
166 } | 155 } |
167 | 156 |
168 | |
169 VM_UNIT_TEST_CASE(IsAbsoluteUint) { | 157 VM_UNIT_TEST_CASE(IsAbsoluteUint) { |
170 EXPECT(Utils::IsAbsoluteUint(8, 16)); | 158 EXPECT(Utils::IsAbsoluteUint(8, 16)); |
171 EXPECT(Utils::IsAbsoluteUint(8, 0)); | 159 EXPECT(Utils::IsAbsoluteUint(8, 0)); |
172 EXPECT(Utils::IsAbsoluteUint(8, -128)); | 160 EXPECT(Utils::IsAbsoluteUint(8, -128)); |
173 EXPECT(Utils::IsAbsoluteUint(8, 255)); | 161 EXPECT(Utils::IsAbsoluteUint(8, 255)); |
174 EXPECT(!Utils::IsAbsoluteUint(8, 256)); | 162 EXPECT(!Utils::IsAbsoluteUint(8, 256)); |
175 EXPECT(Utils::IsAbsoluteUint(16, 16)); | 163 EXPECT(Utils::IsAbsoluteUint(16, 16)); |
176 EXPECT(Utils::IsAbsoluteUint(16, 0)); | 164 EXPECT(Utils::IsAbsoluteUint(16, 0)); |
177 EXPECT(Utils::IsAbsoluteUint(16, 65535)); | 165 EXPECT(Utils::IsAbsoluteUint(16, 65535)); |
178 EXPECT(Utils::IsAbsoluteUint(16, -32768)); | 166 EXPECT(Utils::IsAbsoluteUint(16, -32768)); |
179 EXPECT(!Utils::IsAbsoluteUint(16, 65536)); | 167 EXPECT(!Utils::IsAbsoluteUint(16, 65536)); |
180 EXPECT(Utils::IsAbsoluteUint(32, 16LL)); | 168 EXPECT(Utils::IsAbsoluteUint(32, 16LL)); |
181 EXPECT(Utils::IsAbsoluteUint(32, 0LL)); | 169 EXPECT(Utils::IsAbsoluteUint(32, 0LL)); |
182 EXPECT(Utils::IsAbsoluteUint(32, -2147483648LL)); | 170 EXPECT(Utils::IsAbsoluteUint(32, -2147483648LL)); |
183 EXPECT(Utils::IsAbsoluteUint(32, 4294967295LL)); | 171 EXPECT(Utils::IsAbsoluteUint(32, 4294967295LL)); |
184 EXPECT(!Utils::IsAbsoluteUint(32, 4294967296LL)); | 172 EXPECT(!Utils::IsAbsoluteUint(32, 4294967296LL)); |
185 } | 173 } |
186 | 174 |
187 | |
188 VM_UNIT_TEST_CASE(LowBits) { | 175 VM_UNIT_TEST_CASE(LowBits) { |
189 EXPECT_EQ(0xff00, Utils::Low16Bits(0xffff00)); | 176 EXPECT_EQ(0xff00, Utils::Low16Bits(0xffff00)); |
190 EXPECT_EQ(0xff, Utils::High16Bits(0xffff00)); | 177 EXPECT_EQ(0xff, Utils::High16Bits(0xffff00)); |
191 EXPECT_EQ(0xff00, Utils::Low32Bits(0xff0000ff00LL)); | 178 EXPECT_EQ(0xff00, Utils::Low32Bits(0xff0000ff00LL)); |
192 EXPECT_EQ(0xff, Utils::High32Bits(0xff0000ff00LL)); | 179 EXPECT_EQ(0xff, Utils::High32Bits(0xff0000ff00LL)); |
193 EXPECT_EQ(0x00ff0000ff00LL, Utils::LowHighTo64Bits(0xff00, 0x00ff)); | 180 EXPECT_EQ(0x00ff0000ff00LL, Utils::LowHighTo64Bits(0xff00, 0x00ff)); |
194 } | 181 } |
195 | 182 |
196 | |
197 VM_UNIT_TEST_CASE(Endianity) { | 183 VM_UNIT_TEST_CASE(Endianity) { |
198 uint16_t value16be = Utils::HostToBigEndian16(0xf1); | 184 uint16_t value16be = Utils::HostToBigEndian16(0xf1); |
199 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value16be)[0]); | 185 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value16be)[0]); |
200 EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value16be)[1]); | 186 EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value16be)[1]); |
201 | 187 |
202 uint16_t value16le = Utils::HostToLittleEndian16(0xf1); | 188 uint16_t value16le = Utils::HostToLittleEndian16(0xf1); |
203 EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value16le)[0]); | 189 EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value16le)[0]); |
204 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value16le)[1]); | 190 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value16le)[1]); |
205 | 191 |
206 uint32_t value32be = Utils::HostToBigEndian32(0xf1f2); | 192 uint32_t value32be = Utils::HostToBigEndian32(0xf1f2); |
(...skipping 22 matching lines...) Expand all Loading... |
229 EXPECT_EQ(0xf4, reinterpret_cast<uint8_t*>(&value64le)[0]); | 215 EXPECT_EQ(0xf4, reinterpret_cast<uint8_t*>(&value64le)[0]); |
230 EXPECT_EQ(0xf3, reinterpret_cast<uint8_t*>(&value64le)[1]); | 216 EXPECT_EQ(0xf3, reinterpret_cast<uint8_t*>(&value64le)[1]); |
231 EXPECT_EQ(0xf2, reinterpret_cast<uint8_t*>(&value64le)[2]); | 217 EXPECT_EQ(0xf2, reinterpret_cast<uint8_t*>(&value64le)[2]); |
232 EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value64le)[3]); | 218 EXPECT_EQ(0xf1, reinterpret_cast<uint8_t*>(&value64le)[3]); |
233 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[4]); | 219 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[4]); |
234 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[5]); | 220 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[5]); |
235 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[6]); | 221 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[6]); |
236 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[7]); | 222 EXPECT_EQ(0x0, reinterpret_cast<uint8_t*>(&value64le)[7]); |
237 } | 223 } |
238 | 224 |
239 | |
240 VM_UNIT_TEST_CASE(DoublesBitEqual) { | 225 VM_UNIT_TEST_CASE(DoublesBitEqual) { |
241 EXPECT(Utils::DoublesBitEqual(1.0, 1.0)); | 226 EXPECT(Utils::DoublesBitEqual(1.0, 1.0)); |
242 EXPECT(!Utils::DoublesBitEqual(1.0, -1.0)); | 227 EXPECT(!Utils::DoublesBitEqual(1.0, -1.0)); |
243 EXPECT(Utils::DoublesBitEqual(0.0, 0.0)); | 228 EXPECT(Utils::DoublesBitEqual(0.0, 0.0)); |
244 EXPECT(!Utils::DoublesBitEqual(0.0, -0.0)); | 229 EXPECT(!Utils::DoublesBitEqual(0.0, -0.0)); |
245 EXPECT(Utils::DoublesBitEqual(NAN, NAN)); | 230 EXPECT(Utils::DoublesBitEqual(NAN, NAN)); |
246 } | 231 } |
247 | 232 |
248 } // namespace dart | 233 } // namespace dart |
OLD | NEW |