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