//===- llvm/unittest/Support/LEB128Test.cpp - LEB128 function tests -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/LEB128.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/raw_ostream.h"
#include "gtest/gtest.h"
#include <string>
using namespace llvm;

namespace {

TEST(LEB128Test, EncodeSLEB128) {
#define EXPECT_SLEB128_EQ(EXPECTED, VALUE, PAD) \
  do { \
    std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \
    \
    /* encodeSLEB128(uint64_t, raw_ostream &, unsigned) */ \
    std::string Actual1; \
    raw_string_ostream Stream(Actual1); \
    encodeSLEB128(VALUE, Stream, PAD); \
    Stream.flush(); \
    EXPECT_EQ(Expected, Actual1); \
    \
    /* encodeSLEB128(uint64_t, uint8_t *, unsigned) */ \
    uint8_t Buffer[32]; \
    unsigned Size = encodeSLEB128(VALUE, Buffer, PAD); \
    std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
    EXPECT_EQ(Expected, Actual2); \
  } while (0)

  // Encode SLEB128
  EXPECT_SLEB128_EQ("\x00", 0, 0);
  EXPECT_SLEB128_EQ("\x01", 1, 0);
  EXPECT_SLEB128_EQ("\x7f", -1, 0);
  EXPECT_SLEB128_EQ("\x3f", 63, 0);
  EXPECT_SLEB128_EQ("\x41", -63, 0);
  EXPECT_SLEB128_EQ("\x40", -64, 0);
  EXPECT_SLEB128_EQ("\xbf\x7f", -65, 0);
  EXPECT_SLEB128_EQ("\xc0\x00", 64, 0);

  // Encode SLEB128 with some extra padding bytes
  EXPECT_SLEB128_EQ("\x80\x00", 0, 2);
  EXPECT_SLEB128_EQ("\x80\x80\x00", 0, 3);
  EXPECT_SLEB128_EQ("\xff\x80\x00", 0x7f, 3);
  EXPECT_SLEB128_EQ("\xff\x80\x80\x00", 0x7f, 4);
  EXPECT_SLEB128_EQ("\x80\x81\x00", 0x80, 3);
  EXPECT_SLEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
  EXPECT_SLEB128_EQ("\xc0\x7f", -0x40, 2);

  EXPECT_SLEB128_EQ("\xc0\xff\x7f", -0x40, 3);
  EXPECT_SLEB128_EQ("\x80\xff\x7f", -0x80, 3);
  EXPECT_SLEB128_EQ("\x80\xff\xff\x7f", -0x80, 4);

#undef EXPECT_SLEB128_EQ
}

TEST(LEB128Test, EncodeULEB128) {
#define EXPECT_ULEB128_EQ(EXPECTED, VALUE, PAD) \
  do { \
    std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \
    \
    /* encodeULEB128(uint64_t, raw_ostream &, unsigned) */ \
    std::string Actual1; \
    raw_string_ostream Stream(Actual1); \
    encodeULEB128(VALUE, Stream, PAD); \
    Stream.flush(); \
    EXPECT_EQ(Expected, Actual1); \
    \
    /* encodeULEB128(uint64_t, uint8_t *, unsigned) */ \
    uint8_t Buffer[32]; \
    unsigned Size = encodeULEB128(VALUE, Buffer, PAD); \
    std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
    EXPECT_EQ(Expected, Actual2); \
  } while (0)

  // Encode ULEB128
  EXPECT_ULEB128_EQ("\x00", 0, 0);
  EXPECT_ULEB128_EQ("\x01", 1, 0);
  EXPECT_ULEB128_EQ("\x3f", 63, 0);
  EXPECT_ULEB128_EQ("\x40", 64, 0);
  EXPECT_ULEB128_EQ("\x7f", 0x7f, 0);
  EXPECT_ULEB128_EQ("\x80\x01", 0x80, 0);
  EXPECT_ULEB128_EQ("\x81\x01", 0x81, 0);
  EXPECT_ULEB128_EQ("\x90\x01", 0x90, 0);
  EXPECT_ULEB128_EQ("\xff\x01", 0xff, 0);
  EXPECT_ULEB128_EQ("\x80\x02", 0x100, 0);
  EXPECT_ULEB128_EQ("\x81\x02", 0x101, 0);

  // Encode ULEB128 with some extra padding bytes
  EXPECT_ULEB128_EQ("\x80\x00", 0, 2);
  EXPECT_ULEB128_EQ("\x80\x80\x00", 0, 3);
  EXPECT_ULEB128_EQ("\xff\x00", 0x7f, 2);
  EXPECT_ULEB128_EQ("\xff\x80\x00", 0x7f, 3);
  EXPECT_ULEB128_EQ("\x80\x81\x00", 0x80, 3);
  EXPECT_ULEB128_EQ("\x80\x81\x80\x00", 0x80, 4);

#undef EXPECT_ULEB128_EQ
}

TEST(LEB128Test, DecodeULEB128) {
#define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \
  do { \
    unsigned ActualSize = 0; \
    uint64_t Actual = decodeULEB128(reinterpret_cast<const uint8_t *>(VALUE), \
                                    &ActualSize); \
    EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
    EXPECT_EQ(EXPECTED, Actual); \
  } while (0)

  // Don't crash
  EXPECT_EQ(0u, decodeULEB128(nullptr, nullptr, nullptr));

  // Decode ULEB128
  EXPECT_DECODE_ULEB128_EQ(0u, "\x00");
  EXPECT_DECODE_ULEB128_EQ(1u, "\x01");
  EXPECT_DECODE_ULEB128_EQ(63u, "\x3f");
  EXPECT_DECODE_ULEB128_EQ(64u, "\x40");
  EXPECT_DECODE_ULEB128_EQ(0x7fu, "\x7f");
  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x01");
  EXPECT_DECODE_ULEB128_EQ(0x81u, "\x81\x01");
  EXPECT_DECODE_ULEB128_EQ(0x90u, "\x90\x01");
  EXPECT_DECODE_ULEB128_EQ(0xffu, "\xff\x01");
  EXPECT_DECODE_ULEB128_EQ(0x100u, "\x80\x02");
  EXPECT_DECODE_ULEB128_EQ(0x101u, "\x81\x02");
  EXPECT_DECODE_ULEB128_EQ(4294975616ULL, "\x80\xc1\x80\x80\x10");

  // Decode ULEB128 with extra padding bytes
  EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x00");
  EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x80\x00");
  EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x00");
  EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x80\x00");
  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x00");
  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x00");
  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x80\x80\x80\x80\x80\x80\x00");
  EXPECT_DECODE_ULEB128_EQ(0x80000000'00000000ul,
                           "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01");

#undef EXPECT_DECODE_ULEB128_EQ
}

TEST(LEB128Test, DecodeInvalidULEB128) {
#define EXPECT_INVALID_ULEB128(VALUE, ERROR_OFFSET)                            \
  do {                                                                         \
    const char *DefaultValue = VALUE;                                          \
    const uint8_t *Value = reinterpret_cast<const uint8_t *>(DefaultValue);    \
    const char *Error = nullptr;                                               \
    unsigned ErrorOffset = 0;                                                  \
    uint64_t Actual =                                                          \
        decodeULEB128(Value, &ErrorOffset, Value + strlen(VALUE), &Error);     \
    EXPECT_NE(Error, nullptr);                                                 \
    EXPECT_EQ(0ul, Actual);                                                    \
    EXPECT_EQ(ERROR_OFFSET, ErrorOffset);                                      \
    Value = reinterpret_cast<const uint8_t *>(DefaultValue);                   \
    Error = nullptr;                                                           \
    Actual = decodeULEB128AndInc(Value, Value + strlen(VALUE), &Error);        \
    EXPECT_NE(Error, nullptr);                                                 \
    EXPECT_EQ(0ul, Actual);                                                    \
    EXPECT_EQ(ERROR_OFFSET,                                                    \
              Value - reinterpret_cast<const uint8_t *>(DefaultValue));        \
  } while (0)

  // Buffer overflow.
  EXPECT_INVALID_ULEB128("", 0u);
  EXPECT_INVALID_ULEB128("\x80", 1u);

  // Does not fit in 64 bits.
  EXPECT_INVALID_ULEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 9u);
  EXPECT_INVALID_ULEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 10u);

#undef EXPECT_INVALID_ULEB128
}

TEST(LEB128Test, DecodeSLEB128) {
#define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \
  do { \
    unsigned ActualSize = 0; \
    int64_t Actual = decodeSLEB128(reinterpret_cast<const uint8_t *>(VALUE), \
                                    &ActualSize); \
    EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
    EXPECT_EQ(EXPECTED, Actual); \
  } while (0)

  // Don't crash
  EXPECT_EQ(0, decodeSLEB128(nullptr, nullptr, nullptr));

  // Decode SLEB128
  EXPECT_DECODE_SLEB128_EQ(0L, "\x00");
  EXPECT_DECODE_SLEB128_EQ(1L, "\x01");
  EXPECT_DECODE_SLEB128_EQ(63L, "\x3f");
  EXPECT_DECODE_SLEB128_EQ(-64L, "\x40");
  EXPECT_DECODE_SLEB128_EQ(-63L, "\x41");
  EXPECT_DECODE_SLEB128_EQ(-1L, "\x7f");
  EXPECT_DECODE_SLEB128_EQ(128L, "\x80\x01");
  EXPECT_DECODE_SLEB128_EQ(129L, "\x81\x01");
  EXPECT_DECODE_SLEB128_EQ(-129L, "\xff\x7e");
  EXPECT_DECODE_SLEB128_EQ(-128L, "\x80\x7f");
  EXPECT_DECODE_SLEB128_EQ(-127L, "\x81\x7f");
  EXPECT_DECODE_SLEB128_EQ(64L, "\xc0\x00");
  EXPECT_DECODE_SLEB128_EQ(-12345L, "\xc7\x9f\x7f");

  // Decode unnormalized SLEB128 with extra padding bytes.
  EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x00");
  EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x80\x00");
  EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x00");
  EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x80\x00");
  EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x00");
  EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x00");
  EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x80\x80\x80\x80\x80\x80\x00");
  EXPECT_DECODE_SLEB128_EQ(-2L, "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F");
  EXPECT_DECODE_SLEB128_EQ(INT64_MIN,
                           "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7F");
  EXPECT_DECODE_SLEB128_EQ(INT64_MAX,
                           "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00");

#undef EXPECT_DECODE_SLEB128_EQ
}

TEST(LEB128Test, DecodeInvalidSLEB128) {
#define EXPECT_INVALID_SLEB128(VALUE, ERROR_OFFSET)                            \
  do {                                                                         \
    const char *DefaultValue = VALUE;                                          \
    const uint8_t *Value = reinterpret_cast<const uint8_t *>(DefaultValue);    \
    const char *Error = nullptr;                                               \
    unsigned ErrorOffset = 0;                                                  \
    uint64_t Actual =                                                          \
        decodeSLEB128(Value, &ErrorOffset, Value + strlen(VALUE), &Error);     \
    EXPECT_NE(Error, nullptr);                                                 \
    EXPECT_EQ(0ul, Actual);                                                    \
    EXPECT_EQ(ERROR_OFFSET, ErrorOffset);                                      \
    Value = reinterpret_cast<const uint8_t *>(DefaultValue);                   \
    Error = nullptr;                                                           \
    Actual = decodeSLEB128AndInc(Value, Value + strlen(VALUE), &Error);        \
    EXPECT_NE(Error, nullptr);                                                 \
    EXPECT_EQ(0ul, Actual);                                                    \
    EXPECT_EQ(ERROR_OFFSET,                                                    \
              Value - reinterpret_cast<const uint8_t *>(DefaultValue));        \
  } while (0)

  // Buffer overflow.
  EXPECT_INVALID_SLEB128("", 0u);
  EXPECT_INVALID_SLEB128("\x80", 1u);

  // Does not fit in 64 bits.
  EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 9u);
  EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E", 9u);
  EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 10u);
  EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7E", 9u);
  EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01", 9u);
  EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7E", 10u);
  EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00", 10u);

#undef EXPECT_INVALID_SLEB128
}

TEST(LEB128Test, DecodeAndInc) {
#define EXPECT_LEB128(FUN, VALUE, SIZE)                                        \
  do {                                                                         \
    const char *DefaultValue = VALUE;                                          \
    const uint8_t *V = reinterpret_cast<const uint8_t *>(DefaultValue),        \
                  *P = V;                                                      \
    auto Expected = FUN(P), Actual = FUN##AndInc(P, P + strlen(VALUE));        \
    EXPECT_EQ(Actual, Expected);                                               \
    EXPECT_EQ(P - V, SIZE);                                                    \
  } while (0)
  EXPECT_LEB128(decodeULEB128, "\x7f", 1);
  EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);
  EXPECT_LEB128(decodeSLEB128, "\x7f", 1);
  EXPECT_LEB128(decodeSLEB128, "\x80\x01", 2);
#undef EXPECT_LEB128

#define EXPECT_LEB128(FUN, VALUE, SIZE)                                        \
  do {                                                                         \
    const uint8_t *V = reinterpret_cast<const uint8_t *>(VALUE), *P = V;       \
    auto Expected = FUN(P), Actual = FUN##AndIncUnsafe(P);                     \
    EXPECT_EQ(Actual, Expected);                                               \
    EXPECT_EQ(P - V, SIZE);                                                    \
  } while (0)
  EXPECT_LEB128(decodeULEB128, "\x7f", 1);
  EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);
#undef EXPECT_LEB128
}

TEST(LEB128Test, SLEB128Size) {
  // Positive Value Testing Plan:
  // (1) 128 ^ n - 1 ........ need (n+1) bytes
  // (2) 128 ^ n ............ need (n+1) bytes
  // (3) 128 ^ n * 63 ....... need (n+1) bytes
  // (4) 128 ^ n * 64 - 1 ... need (n+1) bytes
  // (5) 128 ^ n * 64 ....... need (n+2) bytes

  EXPECT_EQ(1u, getSLEB128Size(0x0LL));
  EXPECT_EQ(1u, getSLEB128Size(0x1LL));
  EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
  EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
  EXPECT_EQ(2u, getSLEB128Size(0x40LL));

  EXPECT_EQ(2u, getSLEB128Size(0x7fLL));
  EXPECT_EQ(2u, getSLEB128Size(0x80LL));
  EXPECT_EQ(2u, getSLEB128Size(0x1f80LL));
  EXPECT_EQ(2u, getSLEB128Size(0x1fffLL));
  EXPECT_EQ(3u, getSLEB128Size(0x2000LL));

  EXPECT_EQ(3u, getSLEB128Size(0x3fffLL));
  EXPECT_EQ(3u, getSLEB128Size(0x4000LL));
  EXPECT_EQ(3u, getSLEB128Size(0xfc000LL));
  EXPECT_EQ(3u, getSLEB128Size(0xfffffLL));
  EXPECT_EQ(4u, getSLEB128Size(0x100000LL));

  EXPECT_EQ(4u, getSLEB128Size(0x1fffffLL));
  EXPECT_EQ(4u, getSLEB128Size(0x200000LL));
  EXPECT_EQ(4u, getSLEB128Size(0x7e00000LL));
  EXPECT_EQ(4u, getSLEB128Size(0x7ffffffLL));
  EXPECT_EQ(5u, getSLEB128Size(0x8000000LL));

  EXPECT_EQ(5u, getSLEB128Size(0xfffffffLL));
  EXPECT_EQ(5u, getSLEB128Size(0x10000000LL));
  EXPECT_EQ(5u, getSLEB128Size(0x3f0000000LL));
  EXPECT_EQ(5u, getSLEB128Size(0x3ffffffffLL));
  EXPECT_EQ(6u, getSLEB128Size(0x400000000LL));

  EXPECT_EQ(6u, getSLEB128Size(0x7ffffffffLL));
  EXPECT_EQ(6u, getSLEB128Size(0x800000000LL));
  EXPECT_EQ(6u, getSLEB128Size(0x1f800000000LL));
  EXPECT_EQ(6u, getSLEB128Size(0x1ffffffffffLL));
  EXPECT_EQ(7u, getSLEB128Size(0x20000000000LL));

  EXPECT_EQ(7u, getSLEB128Size(0x3ffffffffffLL));
  EXPECT_EQ(7u, getSLEB128Size(0x40000000000LL));
  EXPECT_EQ(7u, getSLEB128Size(0xfc0000000000LL));
  EXPECT_EQ(7u, getSLEB128Size(0xffffffffffffLL));
  EXPECT_EQ(8u, getSLEB128Size(0x1000000000000LL));

  EXPECT_EQ(8u, getSLEB128Size(0x1ffffffffffffLL));
  EXPECT_EQ(8u, getSLEB128Size(0x2000000000000LL));
  EXPECT_EQ(8u, getSLEB128Size(0x7e000000000000LL));
  EXPECT_EQ(8u, getSLEB128Size(0x7fffffffffffffLL));
  EXPECT_EQ(9u, getSLEB128Size(0x80000000000000LL));

  EXPECT_EQ(9u, getSLEB128Size(0xffffffffffffffLL));
  EXPECT_EQ(9u, getSLEB128Size(0x100000000000000LL));
  EXPECT_EQ(9u, getSLEB128Size(0x3f00000000000000LL));
  EXPECT_EQ(9u, getSLEB128Size(0x3fffffffffffffffLL));
  EXPECT_EQ(10u, getSLEB128Size(0x4000000000000000LL));

  EXPECT_EQ(10u, getSLEB128Size(0x7fffffffffffffffLL));
  EXPECT_EQ(10u, getSLEB128Size(INT64_MAX));

  // Negative Value Testing Plan:
  // (1) - 128 ^ n - 1 ........ need (n+1) bytes
  // (2) - 128 ^ n ............ need (n+1) bytes
  // (3) - 128 ^ n * 63 ....... need (n+1) bytes
  // (4) - 128 ^ n * 64 ....... need (n+1) bytes (different from positive one)
  // (5) - 128 ^ n * 65 - 1 ... need (n+2) bytes (if n > 0)
  // (6) - 128 ^ n * 65 ....... need (n+2) bytes

  EXPECT_EQ(1u, getSLEB128Size(0x0LL));
  EXPECT_EQ(1u, getSLEB128Size(-0x1LL));
  EXPECT_EQ(1u, getSLEB128Size(-0x3fLL));
  EXPECT_EQ(1u, getSLEB128Size(-0x40LL));
  EXPECT_EQ(1u, getSLEB128Size(-0x40LL)); // special case
  EXPECT_EQ(2u, getSLEB128Size(-0x41LL));

  EXPECT_EQ(2u, getSLEB128Size(-0x7fLL));
  EXPECT_EQ(2u, getSLEB128Size(-0x80LL));
  EXPECT_EQ(2u, getSLEB128Size(-0x1f80LL));
  EXPECT_EQ(2u, getSLEB128Size(-0x2000LL));
  EXPECT_EQ(3u, getSLEB128Size(-0x207fLL));
  EXPECT_EQ(3u, getSLEB128Size(-0x2080LL));

  EXPECT_EQ(3u, getSLEB128Size(-0x3fffLL));
  EXPECT_EQ(3u, getSLEB128Size(-0x4000LL));
  EXPECT_EQ(3u, getSLEB128Size(-0xfc000LL));
  EXPECT_EQ(3u, getSLEB128Size(-0x100000LL));
  EXPECT_EQ(4u, getSLEB128Size(-0x103fffLL));
  EXPECT_EQ(4u, getSLEB128Size(-0x104000LL));

  EXPECT_EQ(4u, getSLEB128Size(-0x1fffffLL));
  EXPECT_EQ(4u, getSLEB128Size(-0x200000LL));
  EXPECT_EQ(4u, getSLEB128Size(-0x7e00000LL));
  EXPECT_EQ(4u, getSLEB128Size(-0x8000000LL));
  EXPECT_EQ(5u, getSLEB128Size(-0x81fffffLL));
  EXPECT_EQ(5u, getSLEB128Size(-0x8200000LL));

  EXPECT_EQ(5u, getSLEB128Size(-0xfffffffLL));
  EXPECT_EQ(5u, getSLEB128Size(-0x10000000LL));
  EXPECT_EQ(5u, getSLEB128Size(-0x3f0000000LL));
  EXPECT_EQ(5u, getSLEB128Size(-0x400000000LL));
  EXPECT_EQ(6u, getSLEB128Size(-0x40fffffffLL));
  EXPECT_EQ(6u, getSLEB128Size(-0x410000000LL));

  EXPECT_EQ(6u, getSLEB128Size(-0x7ffffffffLL));
  EXPECT_EQ(6u, getSLEB128Size(-0x800000000LL));
  EXPECT_EQ(6u, getSLEB128Size(-0x1f800000000LL));
  EXPECT_EQ(6u, getSLEB128Size(-0x20000000000LL));
  EXPECT_EQ(7u, getSLEB128Size(-0x207ffffffffLL));
  EXPECT_EQ(7u, getSLEB128Size(-0x20800000000LL));

  EXPECT_EQ(7u, getSLEB128Size(-0x3ffffffffffLL));
  EXPECT_EQ(7u, getSLEB128Size(-0x40000000000LL));
  EXPECT_EQ(7u, getSLEB128Size(-0xfc0000000000LL));
  EXPECT_EQ(7u, getSLEB128Size(-0x1000000000000LL));
  EXPECT_EQ(8u, getSLEB128Size(-0x103ffffffffffLL));
  EXPECT_EQ(8u, getSLEB128Size(-0x1040000000000LL));

  EXPECT_EQ(8u, getSLEB128Size(-0x1ffffffffffffLL));
  EXPECT_EQ(8u, getSLEB128Size(-0x2000000000000LL));
  EXPECT_EQ(8u, getSLEB128Size(-0x7e000000000000LL));
  EXPECT_EQ(8u, getSLEB128Size(-0x80000000000000LL));
  EXPECT_EQ(9u, getSLEB128Size(-0x81ffffffffffffLL));
  EXPECT_EQ(9u, getSLEB128Size(-0x82000000000000LL));

  EXPECT_EQ(9u, getSLEB128Size(-0xffffffffffffffLL));
  EXPECT_EQ(9u, getSLEB128Size(-0x100000000000000LL));
  EXPECT_EQ(9u, getSLEB128Size(-0x3f00000000000000LL));
  EXPECT_EQ(9u, getSLEB128Size(-0x4000000000000000LL));
  EXPECT_EQ(10u, getSLEB128Size(-0x40ffffffffffffffLL));
  EXPECT_EQ(10u, getSLEB128Size(-0x4100000000000000LL));

  EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL));
  EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL - 1));
  EXPECT_EQ(10u, getSLEB128Size(INT64_MIN));
}

TEST(LEB128Test, ULEB128Size) {
  // Testing Plan:
  // (1) 128 ^ n ............ need (n+1) bytes
  // (2) 128 ^ n * 64 ....... need (n+1) bytes
  // (3) 128 ^ (n+1) - 1 .... need (n+1) bytes

  EXPECT_EQ(1u, getULEB128Size(0)); // special case

  EXPECT_EQ(1u, getULEB128Size(0x1ULL));
  EXPECT_EQ(1u, getULEB128Size(0x40ULL));
  EXPECT_EQ(1u, getULEB128Size(0x7fULL));

  EXPECT_EQ(2u, getULEB128Size(0x80ULL));
  EXPECT_EQ(2u, getULEB128Size(0x2000ULL));
  EXPECT_EQ(2u, getULEB128Size(0x3fffULL));

  EXPECT_EQ(3u, getULEB128Size(0x4000ULL));
  EXPECT_EQ(3u, getULEB128Size(0x100000ULL));
  EXPECT_EQ(3u, getULEB128Size(0x1fffffULL));

  EXPECT_EQ(4u, getULEB128Size(0x200000ULL));
  EXPECT_EQ(4u, getULEB128Size(0x8000000ULL));
  EXPECT_EQ(4u, getULEB128Size(0xfffffffULL));

  EXPECT_EQ(5u, getULEB128Size(0x10000000ULL));
  EXPECT_EQ(5u, getULEB128Size(0x400000000ULL));
  EXPECT_EQ(5u, getULEB128Size(0x7ffffffffULL));

  EXPECT_EQ(6u, getULEB128Size(0x800000000ULL));
  EXPECT_EQ(6u, getULEB128Size(0x20000000000ULL));
  EXPECT_EQ(6u, getULEB128Size(0x3ffffffffffULL));

  EXPECT_EQ(7u, getULEB128Size(0x40000000000ULL));
  EXPECT_EQ(7u, getULEB128Size(0x1000000000000ULL));
  EXPECT_EQ(7u, getULEB128Size(0x1ffffffffffffULL));

  EXPECT_EQ(8u, getULEB128Size(0x2000000000000ULL));
  EXPECT_EQ(8u, getULEB128Size(0x80000000000000ULL));
  EXPECT_EQ(8u, getULEB128Size(0xffffffffffffffULL));

  EXPECT_EQ(9u, getULEB128Size(0x100000000000000ULL));
  EXPECT_EQ(9u, getULEB128Size(0x4000000000000000ULL));
  EXPECT_EQ(9u, getULEB128Size(0x7fffffffffffffffULL));

  EXPECT_EQ(10u, getULEB128Size(0x8000000000000000ULL));

  EXPECT_EQ(10u, getULEB128Size(UINT64_MAX));
}

}  // anonymous namespace