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