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
15using namespace mcld;
16using namespace mcldtest;
17
18
19// Constructor can do set-up work for all test here.
20LEB128Test::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.
27LEB128Test::~LEB128Test()
28{
29}
30
31// SetUp() will be called immediately before each test.
32void LEB128Test::SetUp()
33{
34}
35
36// TearDown() will be called immediately after each test.
37void LEB128Test::TearDown()
38{
39}
40
41//==========================================================================//
42// Testcases
43//
44
45TEST_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
91TEST_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
137TEST_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
197TEST_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
233TEST_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
278TEST_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
299TEST_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
391TEST_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
416TEST_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
458TEST_F( LEB128Test, Random_Regression_Test) {
459  leb128::ByteType buffer[9];
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
497TEST_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
513TEST_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