1 //===- implTest.cpp -------------------------------------------------------===//
2 //
3 // The MCLinker Project
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #include <mcld/Support/LEB128.h>
10 #include "LEB128Test.h"
11
12 #include <ctime>
13 #include <cstdlib>
14
15 using namespace mcld;
16 using namespace mcldtest;
17
18
19 // Constructor can do set-up work for all test here.
LEB128Test()20 LEB128Test::LEB128Test()
21 {
22 // Initialize the seed for random number generator using during the tests.
23 ::srandom(::time(NULL));
24 }
25
26 // Destructor can do clean-up work that doesn't throw exceptions here.
~LEB128Test()27 LEB128Test::~LEB128Test()
28 {
29 }
30
31 // SetUp() will be called immediately before each test.
SetUp()32 void LEB128Test::SetUp()
33 {
34 }
35
36 // TearDown() will be called immediately after each test.
TearDown()37 void LEB128Test::TearDown()
38 {
39 }
40
41 //==========================================================================//
42 // Testcases
43 //
44
TEST_F(LEB128Test,EncodeULEB_Example_from_Dwarf3_Figure22_Using_32bits)45 TEST_F( LEB128Test, EncodeULEB_Example_from_Dwarf3_Figure22_Using_32bits) {
46 leb128::ByteType buffer[2];
47 leb128::ByteType *result;
48 size_t size;
49
50 result = buffer;
51 size = leb128::encode<uint32_t>(result, 2);
52 ASSERT_EQ(buffer[0], 2);
53 ASSERT_EQ(result, buffer + 1);
54 ASSERT_EQ(size, 1);
55
56 result = buffer;
57 size = leb128::encode<uint32_t>(result, 127);
58 ASSERT_EQ(buffer[0], 127);
59 ASSERT_EQ(result, buffer + 1);
60 ASSERT_EQ(size, 1);
61
62 result = buffer;
63 size = leb128::encode<uint32_t>(result, 128);
64 ASSERT_EQ(buffer[0], 0 + 0x80);
65 ASSERT_EQ(buffer[1], 1);
66 ASSERT_EQ(result, buffer + 2);
67 ASSERT_EQ(size, 2);
68
69 result = buffer;
70 size = leb128::encode<uint32_t>(result, 129);
71 ASSERT_EQ(buffer[0], 1 + 0x80);
72 ASSERT_EQ(buffer[1], 1);
73 ASSERT_EQ(result, buffer + 2);
74 ASSERT_EQ(size, 2);
75
76 result = buffer;
77 size = leb128::encode<uint32_t>(result, 130);
78 ASSERT_EQ(buffer[0], 2 + 0x80);
79 ASSERT_EQ(buffer[1], 1);
80 ASSERT_EQ(result, buffer + 2);
81 ASSERT_EQ(size, 2);
82
83 result = buffer;
84 size = leb128::encode<uint32_t>(result, 12857);
85 ASSERT_EQ(buffer[0], 57 + 0x80);
86 ASSERT_EQ(buffer[1], 100);
87 ASSERT_EQ(result, buffer + 2);
88 ASSERT_EQ(size, 2);
89 }
90
TEST_F(LEB128Test,EncodeULEB_Example_from_Dwarf3_Figure22_Using_64bits)91 TEST_F( LEB128Test, EncodeULEB_Example_from_Dwarf3_Figure22_Using_64bits) {
92 leb128::ByteType buffer[2];
93 leb128::ByteType *result;
94 size_t size;
95
96 result = buffer;
97 size = leb128::encode<uint64_t>(result, 2);
98 ASSERT_EQ(buffer[0], 2);
99 ASSERT_EQ(result, buffer + 1);
100 ASSERT_EQ(size, 1);
101
102 result = buffer;
103 size = leb128::encode<uint64_t>(result, 127);
104 ASSERT_EQ(buffer[0], 127);
105 ASSERT_EQ(result, buffer + 1);
106 ASSERT_EQ(size, 1);
107
108 result = buffer;
109 size = leb128::encode<uint64_t>(result, 128);
110 ASSERT_EQ(buffer[0], 0 + 0x80);
111 ASSERT_EQ(buffer[1], 1);
112 ASSERT_EQ(result, buffer + 2);
113 ASSERT_EQ(size, 2);
114
115 result = buffer;
116 size = leb128::encode<uint64_t>(result, 129);
117 ASSERT_EQ(buffer[0], 1 + 0x80);
118 ASSERT_EQ(buffer[1], 1);
119 ASSERT_EQ(result, buffer + 2);
120 ASSERT_EQ(size, 2);
121
122 result = buffer;
123 size = leb128::encode<uint64_t>(result, 130);
124 ASSERT_EQ(buffer[0], 2 + 0x80);
125 ASSERT_EQ(buffer[1], 1);
126 ASSERT_EQ(result, buffer + 2);
127 ASSERT_EQ(size, 2);
128
129 result = buffer;
130 size = leb128::encode<uint64_t>(result, 12857);
131 ASSERT_EQ(buffer[0], 57 + 0x80);
132 ASSERT_EQ(buffer[1], 100);
133 ASSERT_EQ(result, buffer + 2);
134 ASSERT_EQ(size, 2);
135 }
136
TEST_F(LEB128Test,EncodeSLEB_Example_from_Dwarf3_Figure22)137 TEST_F( LEB128Test, EncodeSLEB_Example_from_Dwarf3_Figure22) {
138 leb128::ByteType buffer[2];
139 leb128::ByteType *result;
140 size_t size;
141
142 result = buffer;
143 size = leb128::encode<int32_t>(result, 2);
144 ASSERT_EQ(buffer[0], 2);
145 ASSERT_EQ(result, buffer + 1);
146 ASSERT_EQ(size, 1);
147
148 result = buffer;
149 size = leb128::encode<int32_t>(result, -2);
150 ASSERT_EQ(buffer[0], 0x7e);
151 ASSERT_EQ(result, buffer + 1);
152 ASSERT_EQ(size, 1);
153
154 result = buffer;
155 size = leb128::encode<int32_t>(result, 127);
156 ASSERT_EQ(buffer[0], 127 + 0x80);
157 ASSERT_EQ(buffer[1], 0);
158 ASSERT_EQ(result, buffer + 2);
159 ASSERT_EQ(size, 2);
160
161 result = buffer;
162 size = leb128::encode<int32_t>(result, -127);
163 ASSERT_EQ(buffer[0], 1 + 0x80);
164 ASSERT_EQ(buffer[1], 0x7f);
165 ASSERT_EQ(result, buffer + 2);
166 ASSERT_EQ(size, 2);
167
168 result = buffer;
169 size = leb128::encode<int32_t>(result, 128);
170 ASSERT_EQ(buffer[0], 0 + 0x80);
171 ASSERT_EQ(buffer[1], 1);
172 ASSERT_EQ(result, buffer + 2);
173 ASSERT_EQ(size, 2);
174
175 result = buffer;
176 size = leb128::encode<int32_t>(result, -128);
177 ASSERT_EQ(buffer[0], 0 + 0x80);
178 ASSERT_EQ(buffer[1], 0x7f);
179 ASSERT_EQ(result, buffer + 2);
180 ASSERT_EQ(size, 2);
181
182 result = buffer;
183 size = leb128::encode<int32_t>(result, 129);
184 ASSERT_EQ(buffer[0], 1 + 0x80);
185 ASSERT_EQ(buffer[1], 1);
186 ASSERT_EQ(result, buffer + 2);
187 ASSERT_EQ(size, 2);
188
189 result = buffer;
190 size = leb128::encode<int32_t>(result, -129);
191 ASSERT_EQ(buffer[0], 0x7f + 0x80);
192 ASSERT_EQ(buffer[1], 0x7e);
193 ASSERT_EQ(result, buffer + 2);
194 ASSERT_EQ(size, 2);
195 }
196
TEST_F(LEB128Test,DecodeULEB_Example_from_Dwarf3_Figure22)197 TEST_F( LEB128Test, DecodeULEB_Example_from_Dwarf3_Figure22) {
198 leb128::ByteType buffer[2];
199 size_t size;
200
201 buffer[0] = 2;
202 buffer[1] = 0;
203 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 2);
204 ASSERT_EQ(size, 1);
205
206 buffer[0] = 127;
207 buffer[1] = 0;
208 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 127);
209 ASSERT_EQ(size, 1);
210
211 buffer[0] = 0 + 0x80;
212 buffer[1] = 1;
213 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 128);
214 ASSERT_EQ(size, 2);
215
216 buffer[0] = 1 + 0x80;
217 buffer[1] = 1;
218 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 129);
219 ASSERT_EQ(size, 2);
220
221 buffer[0] = 2 + 0x80;
222 buffer[1] = 1;
223 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 130);
224 ASSERT_EQ(size, 2);
225
226 buffer[0] = 57 + 0x80;
227 buffer[1] = 100;
228 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 12857);
229 ASSERT_EQ(size, 2);
230
231 }
232
TEST_F(LEB128Test,DecodeSLEB_Example_from_Dwarf3_Figure22)233 TEST_F( LEB128Test, DecodeSLEB_Example_from_Dwarf3_Figure22) {
234 leb128::ByteType buffer[2];
235 size_t size;
236
237 buffer[0] = 2;
238 buffer[1] = 0;
239 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), 2);
240 ASSERT_EQ(size, 1);
241
242 buffer[0] = 0x7e;
243 buffer[1] = 0;
244 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), -2);
245 ASSERT_EQ(size, 1);
246
247 buffer[0] = 127 + 0x80;
248 buffer[1] = 0;
249 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), 127);
250 ASSERT_EQ(size, 2);
251
252 buffer[0] = 1 + 0x80;
253 buffer[1] = 0x7f;
254 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), -127);
255 ASSERT_EQ(size, 2);
256
257 buffer[0] = 0 + 0x80;
258 buffer[1] = 1;
259 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), 128);
260 ASSERT_EQ(size, 2);
261
262 buffer[0] = 0 + 0x80;
263 buffer[1] = 0x7f;
264 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), -128);
265 ASSERT_EQ(size, 2);
266
267 buffer[0] = 1 + 0x80;
268 buffer[1] = 1;
269 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), 129);
270 ASSERT_EQ(size, 2);
271
272 buffer[0] = 0x7f + 0x80;
273 buffer[1] = 0x7e;
274 ASSERT_EQ(leb128::decode<int64_t>(buffer, size), -129);
275 ASSERT_EQ(size, 2);
276 }
277
TEST_F(LEB128Test,DecodeULEB_Tests_Found_in_Android_dalvik_dx)278 TEST_F( LEB128Test, DecodeULEB_Tests_Found_in_Android_dalvik_dx) {
279 leb128::ByteType content[2];
280 const leb128::ByteType *p;
281
282 content[0] = 0;
283 p = content;
284 ASSERT_EQ(leb128::decode<uint64_t>(p), 0);
285 ASSERT_EQ(p, content + 1);
286
287 content[0] = 1;
288 p = content;
289 ASSERT_EQ(leb128::decode<uint64_t>(p), 1);
290 ASSERT_EQ(p, content + 1);
291
292 content[0] = 0x80;
293 content[1] = 0x7f;
294 p = content;
295 ASSERT_EQ(leb128::decode<uint64_t>(p), 16256);
296 ASSERT_EQ(p, content + 2);
297 }
298
TEST_F(LEB128Test,EncodeULEB_Tests_Found_in_Android_dalvik_dx)299 TEST_F( LEB128Test, EncodeULEB_Tests_Found_in_Android_dalvik_dx) {
300 leb128::ByteType buffer[5];
301 leb128::ByteType *result;
302 size_t size;
303
304 result = buffer;
305 size = leb128::encode<uint32_t>(result, 0);
306 ASSERT_EQ(buffer[0], 0);
307 ASSERT_EQ(result, buffer + 1);
308 ASSERT_EQ(size, 1);
309
310 result = buffer;
311 size = leb128::encode<uint64_t>(result, 0);
312 ASSERT_EQ(buffer[0], 0);
313 ASSERT_EQ(result, buffer + 1);
314 ASSERT_EQ(size, 1);
315
316 result = buffer;
317 size = leb128::encode<uint32_t>(result, 1);
318 ASSERT_EQ(buffer[0], 1);
319 ASSERT_EQ(result, buffer + 1);
320 ASSERT_EQ(size, 1);
321
322 result = buffer;
323 size = leb128::encode<uint64_t>(result, 1);
324 ASSERT_EQ(buffer[0], 1);
325 ASSERT_EQ(result, buffer + 1);
326 ASSERT_EQ(size, 1);
327
328 result = buffer;
329 size = leb128::encode<uint32_t>(result, 16256);
330 ASSERT_EQ(buffer[0], 0x80);
331 ASSERT_EQ(buffer[1], 0x7f);
332 ASSERT_EQ(result, buffer + 2);
333 ASSERT_EQ(size, 2);
334
335 result = buffer;
336 size = leb128::encode<uint64_t>(result, 16256);
337 ASSERT_EQ(buffer[0], 0x80);
338 ASSERT_EQ(buffer[1], 0x7f);
339 ASSERT_EQ(result, buffer + 2);
340 ASSERT_EQ(size, 2);
341
342 result = buffer;
343 size = leb128::encode<uint32_t>(result, 0x3b4);
344 ASSERT_EQ(buffer[0], 0xb4);
345 ASSERT_EQ(buffer[1], 0x07);
346 ASSERT_EQ(result, buffer + 2);
347 ASSERT_EQ(size, 2);
348
349 result = buffer;
350 size = leb128::encode<uint64_t>(result, 0x3b4);
351 ASSERT_EQ(buffer[0], 0xb4);
352 ASSERT_EQ(buffer[1], 0x07);
353 ASSERT_EQ(result, buffer + 2);
354 ASSERT_EQ(size, 2);
355
356 result = buffer;
357 size = leb128::encode<uint32_t>(result, 0x40c);
358 ASSERT_EQ(buffer[0], 0x8c);
359 ASSERT_EQ(buffer[1], 0x08);
360 ASSERT_EQ(result, buffer + 2);
361 ASSERT_EQ(size, 2);
362
363 result = buffer;
364 size = leb128::encode<uint64_t>(result, 0x40c);
365 ASSERT_EQ(buffer[0], 0x8c);
366 ASSERT_EQ(buffer[1], 0x08);
367 ASSERT_EQ(result, buffer + 2);
368 ASSERT_EQ(size, 2);
369
370 result = buffer;
371 size = leb128::encode<uint32_t>(result, 0xffffffff);
372 ASSERT_EQ(buffer[0], 0xff);
373 ASSERT_EQ(buffer[1], 0xff);
374 ASSERT_EQ(buffer[2], 0xff);
375 ASSERT_EQ(buffer[3], 0xff);
376 ASSERT_EQ(buffer[4], 0xf);
377 ASSERT_EQ(result, buffer + 5);
378 ASSERT_EQ(size, 5);
379
380 result = buffer;
381 size = leb128::encode<uint64_t>(result, 0xffffffff);
382 ASSERT_EQ(buffer[0], 0xff);
383 ASSERT_EQ(buffer[1], 0xff);
384 ASSERT_EQ(buffer[2], 0xff);
385 ASSERT_EQ(buffer[3], 0xff);
386 ASSERT_EQ(buffer[4], 0xf);
387 ASSERT_EQ(result, buffer + 5);
388 ASSERT_EQ(size, 5);
389 }
390
TEST_F(LEB128Test,DecodeSLEB_Tests_Found_in_Android_dalvik_dx)391 TEST_F( LEB128Test, DecodeSLEB_Tests_Found_in_Android_dalvik_dx) {
392 leb128::ByteType content[2];
393 const leb128::ByteType *p;
394
395 content[0] = 0;
396 p = content;
397 ASSERT_EQ(leb128::decode<int64_t>(p), 0);
398 ASSERT_EQ(p, content + 1);
399
400 content[0] = 1;
401 p = content;
402 ASSERT_EQ(leb128::decode<int64_t>(p), 1);
403 ASSERT_EQ(p, content + 1);
404
405 content[0] = 0x7f;
406 p = content;
407 ASSERT_EQ(leb128::decode<int64_t>(p), -1);
408 ASSERT_EQ(p, content + 1);
409
410 content[0] = 0x3c;
411 p = content;
412 ASSERT_EQ(leb128::decode<int64_t>(p), 0x3c);
413 ASSERT_EQ(p, content + 1);
414 }
415
TEST_F(LEB128Test,EncodeSLEB_Tests_Found_in_Android_dalvik_dx)416 TEST_F( LEB128Test, EncodeSLEB_Tests_Found_in_Android_dalvik_dx) {
417 leb128::ByteType buffer[5];
418 leb128::ByteType *result;
419 size_t size;
420
421 result = buffer;
422 size = leb128::encode<int32_t>(result, 0);
423 ASSERT_EQ(buffer[0], 0);
424 ASSERT_EQ(result, buffer + 1);
425 ASSERT_EQ(size, 1);
426
427 result = buffer;
428 size = leb128::encode<int64_t>(result, 0);
429 ASSERT_EQ(buffer[0], 0);
430 ASSERT_EQ(result, buffer + 1);
431 ASSERT_EQ(size, 1);
432
433 result = buffer;
434 size = leb128::encode<int32_t>(result, 1);
435 ASSERT_EQ(buffer[0], 1);
436 ASSERT_EQ(result, buffer + 1);
437 ASSERT_EQ(size, 1);
438
439 result = buffer;
440 size = leb128::encode<int64_t>(result, 1);
441 ASSERT_EQ(buffer[0], 1);
442 ASSERT_EQ(result, buffer + 1);
443 ASSERT_EQ(size, 1);
444
445 result = buffer;
446 size = leb128::encode<int32_t>(result, -1);
447 ASSERT_EQ(buffer[0], 0x7f);
448 ASSERT_EQ(result, buffer + 1);
449 ASSERT_EQ(size, 1);
450
451 result = buffer;
452 size = leb128::encode<int64_t>(result, -1);
453 ASSERT_EQ(buffer[0], 0x7f);
454 ASSERT_EQ(result, buffer + 1);
455 ASSERT_EQ(size, 1);
456 }
457
TEST_F(LEB128Test,Random_Regression_Test)458 TEST_F( LEB128Test, Random_Regression_Test) {
459 leb128::ByteType buffer[5];
460
461 for (int i = 0; i < 20; i++) {
462 long int value = random();
463 uint64_t value2 = value * value;
464 leb128::ByteType *result;
465 size_t encode_size, decode_size;
466
467 // Test encode<uint32_t> and decode<uint64_t> on value
468 result = buffer;
469 encode_size = leb128::encode<uint32_t>(result, value);
470 ASSERT_EQ(result, buffer + encode_size);
471 ASSERT_EQ(leb128::decode<uint64_t>(buffer, decode_size), value);
472 ASSERT_EQ(encode_size, decode_size);
473
474 // Test encode<uint64_t> and decode<uint64_t> on (value * value)
475 result = buffer;
476 encode_size = leb128::encode<uint64_t>(result, value2);
477 ASSERT_EQ(result, buffer + encode_size);
478 ASSERT_EQ(leb128::decode<uint64_t>(buffer, decode_size), value2);
479 ASSERT_EQ(encode_size, decode_size);
480
481 // Test encode<uint64_t> and decode<uint64_t> on (value * value)
482 result = buffer;
483 encode_size = leb128::encode<int64_t>(result, value2);
484 ASSERT_EQ(result, buffer + encode_size);
485 ASSERT_EQ(leb128::decode<int64_t>(buffer, decode_size), value2);
486 ASSERT_EQ(encode_size, decode_size);
487
488 // Test encode<uint64_t> and decode<uint64_t> on -(value * value)
489 result = buffer;
490 encode_size = leb128::encode<int64_t>(result, -value2);
491 ASSERT_EQ(result, buffer + encode_size);
492 ASSERT_EQ(leb128::decode<int64_t>(buffer, decode_size), -value2);
493 ASSERT_EQ(encode_size, decode_size);
494 }
495 }
496
TEST_F(LEB128Test,Other_Test)497 TEST_F( LEB128Test, Other_Test) {
498 leb128::ByteType buffer[5];
499 leb128::ByteType *result;
500 size_t size;
501
502 result = buffer;
503 leb128::encode<uint64_t>(result, 154452);
504 ASSERT_EQ(result, buffer + 3);
505 ASSERT_EQ(buffer[0], 0xd4);
506 ASSERT_EQ(buffer[1], 0xb6);
507 ASSERT_EQ(buffer[2], 0x9);
508
509 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 154452);
510 ASSERT_EQ(size, 3);
511 }
512
TEST_F(LEB128Test,Type_Conversion_Test)513 TEST_F( LEB128Test, Type_Conversion_Test) {
514 char buffer[5];
515 char *result;
516 size_t size;
517
518 result = buffer;
519 leb128::encode<uint64_t>(result, 154452);
520 ASSERT_EQ(result, buffer + 3);
521 ASSERT_EQ(buffer[0], '\xd4');
522 ASSERT_EQ(buffer[1], '\xb6');
523 ASSERT_EQ(buffer[2], '\x09');
524
525 ASSERT_EQ(leb128::decode<uint64_t>(buffer, size), 154452);
526 ASSERT_EQ(size, 3);
527
528 const char *p = buffer;
529 ASSERT_EQ(leb128::decode<uint64_t>(p), 154452);
530 ASSERT_EQ(p, buffer + 3);
531 }
532