Line data Source code
1 : // Copyright 2016 the V8 project 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 "test/unittests/test-utils.h"
6 :
7 : #include "src/objects-inl.h"
8 : #include "src/wasm/decoder.h"
9 : #include "src/wasm/leb-helper.h"
10 :
11 : namespace v8 {
12 : namespace internal {
13 : namespace wasm {
14 :
15 12 : class LEBHelperTest : public TestWithZone {};
16 :
17 15444 : TEST_F(LEBHelperTest, sizeof_u32v) {
18 2 : EXPECT_EQ(1u, LEBHelper::sizeof_u32v(0));
19 2 : EXPECT_EQ(1u, LEBHelper::sizeof_u32v(1));
20 2 : EXPECT_EQ(1u, LEBHelper::sizeof_u32v(3));
21 :
22 249 : for (uint32_t i = 4; i < 128; i++) {
23 372 : EXPECT_EQ(1u, LEBHelper::sizeof_u32v(i));
24 : }
25 :
26 769 : for (uint32_t i = (1u << 7); i < (1u << 9); i++) {
27 1152 : EXPECT_EQ(2u, LEBHelper::sizeof_u32v(i));
28 : }
29 :
30 2981 : for (uint32_t i = (1u << 14); i < (1u << 16); i += 33) {
31 4470 : EXPECT_EQ(3u, LEBHelper::sizeof_u32v(i));
32 : }
33 :
34 865 : for (uint32_t i = (1u << 21); i < (1u << 24); i += 33999) {
35 1296 : EXPECT_EQ(4u, LEBHelper::sizeof_u32v(i));
36 : }
37 :
38 113 : for (uint32_t i = (1u << 28); i < (1u << 31); i += 33997779u) {
39 168 : EXPECT_EQ(5u, LEBHelper::sizeof_u32v(i));
40 : }
41 :
42 2 : EXPECT_EQ(5u, LEBHelper::sizeof_u32v(0xFFFFFFFF));
43 1 : }
44 :
45 15444 : TEST_F(LEBHelperTest, sizeof_i32v) {
46 2 : EXPECT_EQ(1u, LEBHelper::sizeof_i32v(0));
47 2 : EXPECT_EQ(1u, LEBHelper::sizeof_i32v(1));
48 2 : EXPECT_EQ(1u, LEBHelper::sizeof_i32v(3));
49 :
50 129 : for (int32_t i = 0; i < (1 << 6); i++) {
51 128 : EXPECT_EQ(1u, LEBHelper::sizeof_i32v(i));
52 : }
53 :
54 385 : for (int32_t i = (1 << 6); i < (1 << 8); i++) {
55 384 : EXPECT_EQ(2u, LEBHelper::sizeof_i32v(i));
56 : }
57 :
58 1587 : for (int32_t i = (1 << 13); i < (1 << 15); i += 31) {
59 1586 : EXPECT_EQ(3u, LEBHelper::sizeof_i32v(i));
60 : }
61 :
62 199 : for (int32_t i = (1 << 20); i < (1 << 22); i += 31991) {
63 198 : EXPECT_EQ(4u, LEBHelper::sizeof_i32v(i));
64 : }
65 :
66 253 : for (int32_t i = (1 << 27); i < (1 << 29); i += 3199893) {
67 252 : EXPECT_EQ(5u, LEBHelper::sizeof_i32v(i));
68 : }
69 :
70 131 : for (int32_t i = -(1 << 6); i <= 0; i++) {
71 130 : EXPECT_EQ(1u, LEBHelper::sizeof_i32v(i));
72 : }
73 :
74 16257 : for (int32_t i = -(1 << 13); i < -(1 << 6); i++) {
75 16256 : EXPECT_EQ(2u, LEBHelper::sizeof_i32v(i));
76 : }
77 :
78 142989 : for (int32_t i = -(1 << 20); i < -(1 << 18); i += 11) {
79 142988 : EXPECT_EQ(3u, LEBHelper::sizeof_i32v(i));
80 : }
81 :
82 16781 : for (int32_t i = -(1 << 27); i < -(1 << 25); i += 11999) {
83 16780 : EXPECT_EQ(4u, LEBHelper::sizeof_i32v(i));
84 : }
85 :
86 1345 : for (int32_t i = -(1 << 30); i < -(1 << 28); i += 1199999) {
87 1344 : EXPECT_EQ(5u, LEBHelper::sizeof_i32v(i));
88 : }
89 1 : }
90 :
91 : #define DECLARE_ENCODE_DECODE_CHECKER(ctype, name) \
92 : static void CheckEncodeDecode_##name(ctype val) { \
93 : static const int kSize = 16; \
94 : static byte buffer[kSize]; \
95 : byte* ptr = buffer; \
96 : LEBHelper::write_##name(&ptr, val); \
97 : EXPECT_EQ(LEBHelper::sizeof_##name(val), \
98 : static_cast<size_t>(ptr - buffer)); \
99 : Decoder decoder(buffer, buffer + kSize); \
100 : unsigned length = 0; \
101 : ctype result = decoder.read_##name<Decoder::kNoValidate>(buffer, &length); \
102 : EXPECT_EQ(val, result); \
103 : EXPECT_EQ(LEBHelper::sizeof_##name(val), static_cast<size_t>(length)); \
104 : }
105 :
106 770 : DECLARE_ENCODE_DECODE_CHECKER(int32_t, i32v)
107 418 : DECLARE_ENCODE_DECODE_CHECKER(uint32_t, u32v)
108 1400 : DECLARE_ENCODE_DECODE_CHECKER(int64_t, i64v)
109 770 : DECLARE_ENCODE_DECODE_CHECKER(uint64_t, u64v)
110 :
111 : #undef DECLARE_ENCODE_DECODE_CHECKER
112 :
113 15444 : TEST_F(LEBHelperTest, WriteAndDecode_u32v) {
114 1 : CheckEncodeDecode_u32v(0);
115 1 : CheckEncodeDecode_u32v(1);
116 1 : CheckEncodeDecode_u32v(5);
117 1 : CheckEncodeDecode_u32v(99);
118 1 : CheckEncodeDecode_u32v(298);
119 1 : CheckEncodeDecode_u32v(87348723);
120 1 : CheckEncodeDecode_u32v(77777);
121 :
122 63 : for (uint32_t val = 0x3A; val != 0; val = val << 1) {
123 31 : CheckEncodeDecode_u32v(val);
124 : }
125 1 : }
126 :
127 15444 : TEST_F(LEBHelperTest, WriteAndDecode_i32v) {
128 1 : CheckEncodeDecode_i32v(0);
129 1 : CheckEncodeDecode_i32v(1);
130 1 : CheckEncodeDecode_i32v(5);
131 1 : CheckEncodeDecode_i32v(99);
132 1 : CheckEncodeDecode_i32v(298);
133 1 : CheckEncodeDecode_i32v(87348723);
134 1 : CheckEncodeDecode_i32v(77777);
135 :
136 1 : CheckEncodeDecode_i32v(-2);
137 1 : CheckEncodeDecode_i32v(-4);
138 1 : CheckEncodeDecode_i32v(-59);
139 1 : CheckEncodeDecode_i32v(-288);
140 1 : CheckEncodeDecode_i32v(-12608);
141 1 : CheckEncodeDecode_i32v(-87328723);
142 1 : CheckEncodeDecode_i32v(-77377);
143 :
144 63 : for (uint32_t val = 0x3A; val != 0; val = val << 1) {
145 31 : CheckEncodeDecode_i32v(bit_cast<int32_t>(val));
146 : }
147 :
148 65 : for (uint32_t val = 0xFFFFFF3B; val != 0; val = val << 1) {
149 32 : CheckEncodeDecode_i32v(bit_cast<int32_t>(val));
150 : }
151 1 : }
152 :
153 15444 : TEST_F(LEBHelperTest, WriteAndDecode_u64v) {
154 1 : CheckEncodeDecode_u64v(0);
155 1 : CheckEncodeDecode_u64v(1);
156 1 : CheckEncodeDecode_u64v(5);
157 1 : CheckEncodeDecode_u64v(99);
158 1 : CheckEncodeDecode_u64v(298);
159 1 : CheckEncodeDecode_u64v(87348723);
160 1 : CheckEncodeDecode_u64v(77777);
161 :
162 127 : for (uint64_t val = 0x3A; val != 0; val = val << 1) {
163 63 : CheckEncodeDecode_u64v(val);
164 : }
165 1 : }
166 :
167 15444 : TEST_F(LEBHelperTest, WriteAndDecode_i64v) {
168 1 : CheckEncodeDecode_i64v(0);
169 1 : CheckEncodeDecode_i64v(1);
170 1 : CheckEncodeDecode_i64v(5);
171 1 : CheckEncodeDecode_i64v(99);
172 1 : CheckEncodeDecode_i64v(298);
173 1 : CheckEncodeDecode_i64v(87348723);
174 1 : CheckEncodeDecode_i64v(77777);
175 :
176 1 : CheckEncodeDecode_i64v(-2);
177 1 : CheckEncodeDecode_i64v(-4);
178 1 : CheckEncodeDecode_i64v(-59);
179 1 : CheckEncodeDecode_i64v(-288);
180 1 : CheckEncodeDecode_i64v(-87648723);
181 1 : CheckEncodeDecode_i64v(-77377);
182 :
183 127 : for (uint64_t val = 0x3A; val != 0; val = val << 1) {
184 63 : CheckEncodeDecode_i64v(bit_cast<int64_t>(val));
185 : }
186 :
187 129 : for (uint64_t val = 0xFFFFFFFFFFFFFF3B; val != 0; val = val << 1) {
188 64 : CheckEncodeDecode_i64v(bit_cast<int64_t>(val));
189 : }
190 1 : }
191 : } // namespace wasm
192 : } // namespace internal
193 9264 : } // namespace v8
|
