unittests/Utility/DataExtractorTest.cpp - llvm-project/lldb - Git at Google

 //===-- DataExtractorTest.cpp ---------------------------------------------===//
 //
 // 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 "gtest/gtest.h"

 #include "lldb/Utility/DataExtractor.h"

 using namespace lldb_private;

 TEST(DataExtractorTest, GetBitfield) {
   uint8_t buffer[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                    sizeof(void *));
   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

   lldb::offset_t offset;

   offset = 0;
   ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
   offset = 0;
   ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
   offset = 0;
   ASSERT_EQ(static_cast<uint64_t>(0xEFCDAB8967452301),
             LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0));
   offset = 0;
   ASSERT_EQ(static_cast<uint64_t>(0x0123456789ABCDEF),
             BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0));
   offset = 0;
   ASSERT_EQ(static_cast<uint64_t>(0x01234567),
             BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 32, 0));
   offset = 0;
   ASSERT_EQ(static_cast<uint64_t>(0x012345678),
             BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 36, 0));

   offset = 0;
   ASSERT_EQ(int8_t(buffer[1]),
             LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
   offset = 0;
   ASSERT_EQ(int8_t(buffer[1]),
             BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
   offset = 0;
   ASSERT_EQ(static_cast<int64_t>(0xEFCDAB8967452301),
             LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 64, 0));
   offset = 0;
   ASSERT_EQ(static_cast<int64_t>(0x0123456789ABCDEF),
             BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 64, 0));
 }

 TEST(DataExtractorTest, PeekData) {
   uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04};
   DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

   EXPECT_EQ(buffer + 0, E.PeekData(0, 0));
   EXPECT_EQ(buffer + 0, E.PeekData(0, 4));
   EXPECT_EQ(nullptr, E.PeekData(0, 5));

   EXPECT_EQ(buffer + 2, E.PeekData(2, 0));
   EXPECT_EQ(buffer + 2, E.PeekData(2, 2));
   EXPECT_EQ(nullptr, E.PeekData(2, 3));

   EXPECT_EQ(buffer + 4, E.PeekData(4, 0));
   EXPECT_EQ(nullptr, E.PeekData(4, 1));
 }

 TEST(DataExtractorTest, GetCStr) {
   uint8_t buffer[] = {'X', 'f', 'o', 'o', '\0'};
   DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

   lldb::offset_t offset = 1;
   EXPECT_STREQ("foo", E.GetCStr(&offset));
   EXPECT_EQ(5U, offset);
 }

 TEST(DataExtractorTest, GetCStrEmpty) {
   uint8_t buffer[] = {'X', '\0'};
   DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

   lldb::offset_t offset = 1;
   EXPECT_STREQ("", E.GetCStr(&offset));
   EXPECT_EQ(2U, offset);
 }

 TEST(DataExtractorTest, GetCStrUnterminated) {
   uint8_t buffer[] = {'X', 'f', 'o', 'o'};
   DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

   lldb::offset_t offset = 1;
   EXPECT_EQ(nullptr, E.GetCStr(&offset));
   EXPECT_EQ(1U, offset);
 }

 TEST(DataExtractorTest, GetCStrAtEnd) {
   uint8_t buffer[] = {'X'};
   DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

   lldb::offset_t offset = 1;
   EXPECT_EQ(nullptr, E.GetCStr(&offset));
   EXPECT_EQ(1U, offset);
 }

 TEST(DataExtractorTest, GetCStrAtNullOffset) {
   uint8_t buffer[] = {'f', 'o', 'o', '\0'};
   DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

   lldb::offset_t offset = 0;
   EXPECT_STREQ("foo", E.GetCStr(&offset));
   EXPECT_EQ(4U, offset);
 }

 TEST(DataExtractorTest, UncommonAddressSize) {
   uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
   DataExtractor E2(buffer, sizeof buffer, lldb::eByteOrderLittle, 2);
   DataExtractor E5(buffer, sizeof buffer, lldb::eByteOrderLittle, 5);
   DataExtractor E7(buffer, sizeof buffer, lldb::eByteOrderLittle, 7);

   lldb::offset_t offset;

   // Test 2-byte addresses (for AVR).
   offset = 0;
   EXPECT_EQ(0x0201U, E2.GetMaxU64(&offset, 2));
   EXPECT_EQ(2U, offset);
   offset = 0;
   EXPECT_EQ(0x0201U, E2.GetAddress(&offset));
   EXPECT_EQ(2U, offset);

   // Test 5-byte addresses.
   offset = 0;
   EXPECT_EQ(0x030201U, E5.GetMaxU64(&offset, 3));
   EXPECT_EQ(3U, offset);
   offset = 3;
   EXPECT_EQ(0x0807060504U, E5.GetAddress(&offset));
   EXPECT_EQ(8U, offset);

   // Test 7-byte addresses.
   offset = 0;
   EXPECT_EQ(0x0504030201U, E7.GetMaxU64(&offset, 5));
   EXPECT_EQ(5U, offset);
   offset = 0;
   EXPECT_EQ(0x07060504030201U, E7.GetAddress(&offset));
   EXPECT_EQ(7U, offset);
 }

 TEST(DataExtractorTest, GetMaxU64) {
   uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                    sizeof(void *));
   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

   lldb::offset_t offset;

   // Check with the minimum allowed byte size.
   offset = 0;
   EXPECT_EQ(0x01U, LE.GetMaxU64(&offset, 1));
   EXPECT_EQ(1U, offset);
   offset = 0;
   EXPECT_EQ(0x01U, BE.GetMaxU64(&offset, 1));
   EXPECT_EQ(1U, offset);

   // Check with a non-zero offset.
   offset = 1;
   EXPECT_EQ(0x0302U, LE.GetMaxU64(&offset, 2));
   EXPECT_EQ(3U, offset);
   offset = 1;
   EXPECT_EQ(0x0203U, BE.GetMaxU64(&offset, 2));
   EXPECT_EQ(3U, offset);

   // Check with the byte size not being a multiple of 2.
   offset = 0;
   EXPECT_EQ(0x07060504030201U, LE.GetMaxU64(&offset, 7));
   EXPECT_EQ(7U, offset);
   offset = 0;
   EXPECT_EQ(0x01020304050607U, BE.GetMaxU64(&offset, 7));
   EXPECT_EQ(7U, offset);

   // Check with the maximum allowed byte size.
   offset = 0;
   EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64(&offset, 8));
   EXPECT_EQ(8U, offset);
   offset = 0;
   EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64(&offset, 8));
   EXPECT_EQ(8U, offset);
 }

 TEST(DataExtractorTest, GetMaxS64) {
   uint8_t buffer[] = {0x01, 0x02, 0x83, 0x04, 0x05, 0x06, 0x07, 0x08};
   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                    sizeof(void *));
   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

   lldb::offset_t offset;

   // Check with the minimum allowed byte size.
   offset = 0;
   EXPECT_EQ(0x01, LE.GetMaxS64(&offset, 1));
   EXPECT_EQ(1U, offset);
   offset = 0;
   EXPECT_EQ(0x01, BE.GetMaxS64(&offset, 1));
   EXPECT_EQ(1U, offset);

   // Check that sign extension works correctly.
   offset = 0;
   int64_t value = LE.GetMaxS64(&offset, 3);
   EXPECT_EQ(0xffffffffff830201U, *reinterpret_cast<uint64_t *>(&value));
   EXPECT_EQ(3U, offset);
   offset = 2;
   value = BE.GetMaxS64(&offset, 3);
   EXPECT_EQ(0xffffffffff830405U, *reinterpret_cast<uint64_t *>(&value));
   EXPECT_EQ(5U, offset);

   // Check with the maximum allowed byte size.
   offset = 0;
   EXPECT_EQ(0x0807060504830201, LE.GetMaxS64(&offset, 8));
   EXPECT_EQ(8U, offset);
   offset = 0;
   EXPECT_EQ(0x0102830405060708, BE.GetMaxS64(&offset, 8));
   EXPECT_EQ(8U, offset);
 }

 TEST(DataExtractorTest, GetMaxU64_unchecked) {
   uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                    sizeof(void *));
   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

   lldb::offset_t offset;

   // Check with the minimum allowed byte size.
   offset = 0;
   EXPECT_EQ(0x01U, LE.GetMaxU64_unchecked(&offset, 1));
   EXPECT_EQ(1U, offset);
   offset = 0;
   EXPECT_EQ(0x01U, BE.GetMaxU64_unchecked(&offset, 1));
   EXPECT_EQ(1U, offset);

   // Check with a non-zero offset.
   offset = 1;
   EXPECT_EQ(0x0302U, LE.GetMaxU64_unchecked(&offset, 2));
   EXPECT_EQ(3U, offset);
   offset = 1;
   EXPECT_EQ(0x0203U, BE.GetMaxU64_unchecked(&offset, 2));
   EXPECT_EQ(3U, offset);

   // Check with the byte size not being a multiple of 2.
   offset = 0;
   EXPECT_EQ(0x07060504030201U, LE.GetMaxU64_unchecked(&offset, 7));
   EXPECT_EQ(7U, offset);
   offset = 0;
   EXPECT_EQ(0x01020304050607U, BE.GetMaxU64_unchecked(&offset, 7));
   EXPECT_EQ(7U, offset);

   // Check with the maximum allowed byte size.
   offset = 0;
   EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64_unchecked(&offset, 8));
   EXPECT_EQ(8U, offset);
   offset = 0;
   EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64_unchecked(&offset, 8));
   EXPECT_EQ(8U, offset);
 }

 TEST(DataExtractorTest, GetSLEB128_bit63) {
   uint8_t buffer[] = {0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x7f};

   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                    sizeof(void *));
   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

   lldb::offset_t offset;

   int64_t expected =
       0b1111111100000001111111000000011111110000000111111100000001111111;
   offset = 0;
   EXPECT_EQ(expected, LE.GetSLEB128(&offset));
   EXPECT_EQ(9U, offset);
   offset = 0;
   EXPECT_EQ(expected, BE.GetSLEB128(&offset));
   EXPECT_EQ(9U, offset);
 }

 TEST(DataExtractorTest, GetULEB128_bit63) {
   uint8_t buffer[] = {0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x7f};

   DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                    sizeof(void *));
   DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

   lldb::offset_t offset;

   uint64_t expected =
       0b0111111100000001111111000000011111110000000111111100000001111111;
   offset = 0;
   EXPECT_EQ(expected, LE.GetULEB128(&offset));
   EXPECT_EQ(9U, offset);
   offset = 0;
   EXPECT_EQ(expected, BE.GetULEB128(&offset));
   EXPECT_EQ(9U, offset);
 }

 TEST(DataExtractorTest, GetFloat) {
   float expected = 4.0f;
   lldb::offset_t offset;

   {
     uint8_t buffer[] = {0x00, 0x00, 0x80, 0x40};
     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                      sizeof(void *));

     offset = 0;
     EXPECT_DOUBLE_EQ(expected, LE.GetFloat(&offset));
     EXPECT_EQ(4U, offset);
   }

   {
     uint8_t buffer[] = {0x40, 0x80, 0x00, 0x00};
     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
                      sizeof(void *));
     offset = 0;
     EXPECT_DOUBLE_EQ(expected, BE.GetFloat(&offset));
     EXPECT_EQ(4U, offset);
   }
 }

 TEST(DataExtractorTest, GetFloatUnaligned) {
   float expected = 4.0f;
   lldb::offset_t offset;

   {
     uint8_t buffer[] = {0x00, 0x00, 0x00, 0x80, 0x40};
     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                      sizeof(void *));

     offset = 1;
     EXPECT_DOUBLE_EQ(expected, LE.GetFloat(&offset));
     EXPECT_EQ(5U, offset);
   }

   {
     uint8_t buffer[] = {0x00, 0x40, 0x80, 0x00, 0x00};
     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
                      sizeof(void *));
     offset = 1;
     EXPECT_DOUBLE_EQ(expected, BE.GetFloat(&offset));
     EXPECT_EQ(5U, offset);
   }
 }

 TEST(DataExtractorTest, GetDouble) {
   if (sizeof(double) != 8)
     return;

   double expected = 4.0f;
   lldb::offset_t offset;

   {
     uint8_t buffer[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x40};
     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                      sizeof(void *));

     offset = 0;
     EXPECT_DOUBLE_EQ(expected, LE.GetDouble(&offset));
     EXPECT_EQ(8U, offset);
   }

   {
     uint8_t buffer[] = {0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
                      sizeof(void *));
     offset = 0;
     EXPECT_DOUBLE_EQ(expected, BE.GetDouble(&offset));
     EXPECT_EQ(8U, offset);
   }
 }

 TEST(DataExtractorTest, GetDoubleUnaligned) {
   if (sizeof(double) != 8)
     return;

   float expected = 4.0f;
   lldb::offset_t offset;

   {
     uint8_t buffer[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x40};
     DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
                      sizeof(void *));

     offset = 1;
     EXPECT_DOUBLE_EQ(expected, LE.GetDouble(&offset));
     EXPECT_EQ(9U, offset);
   }

   {
     uint8_t buffer[] = {0x00, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
     DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
                      sizeof(void *));
     offset = 1;
     EXPECT_DOUBLE_EQ(expected, BE.GetDouble(&offset));
     EXPECT_EQ(9U, offset);
   }
 }
	//===-- DataExtractorTest.cpp ---------------------------------------------===//
	//
	// 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 "gtest/gtest.h"

	#include "lldb/Utility/DataExtractor.h"

	using namespace lldb_private;

	TEST(DataExtractorTest, GetBitfield) {
	uint8_t buffer[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

	lldb::offset_t offset;

	offset = 0;
	ASSERT_EQ(buffer[1], LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
	offset = 0;
	ASSERT_EQ(buffer[1], BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 8, 8));
	offset = 0;
	ASSERT_EQ(static_cast<uint64_t>(0xEFCDAB8967452301),
	LE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0));
	offset = 0;
	ASSERT_EQ(static_cast<uint64_t>(0x0123456789ABCDEF),
	BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 64, 0));
	offset = 0;
	ASSERT_EQ(static_cast<uint64_t>(0x01234567),
	BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 32, 0));
	offset = 0;
	ASSERT_EQ(static_cast<uint64_t>(0x012345678),
	BE.GetMaxU64Bitfield(&offset, sizeof(buffer), 36, 0));

	offset = 0;
	ASSERT_EQ(int8_t(buffer[1]),
	LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
	offset = 0;
	ASSERT_EQ(int8_t(buffer[1]),
	BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 8, 8));
	offset = 0;
	ASSERT_EQ(static_cast<int64_t>(0xEFCDAB8967452301),
	LE.GetMaxS64Bitfield(&offset, sizeof(buffer), 64, 0));
	offset = 0;
	ASSERT_EQ(static_cast<int64_t>(0x0123456789ABCDEF),
	BE.GetMaxS64Bitfield(&offset, sizeof(buffer), 64, 0));
	}

	TEST(DataExtractorTest, PeekData) {
	uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04};
	DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

	EXPECT_EQ(buffer + 0, E.PeekData(0, 0));
	EXPECT_EQ(buffer + 0, E.PeekData(0, 4));
	EXPECT_EQ(nullptr, E.PeekData(0, 5));

	EXPECT_EQ(buffer + 2, E.PeekData(2, 0));
	EXPECT_EQ(buffer + 2, E.PeekData(2, 2));
	EXPECT_EQ(nullptr, E.PeekData(2, 3));

	EXPECT_EQ(buffer + 4, E.PeekData(4, 0));
	EXPECT_EQ(nullptr, E.PeekData(4, 1));
	}

	TEST(DataExtractorTest, GetCStr) {
	uint8_t buffer[] = {'X', 'f', 'o', 'o', '\0'};
	DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

	lldb::offset_t offset = 1;
	EXPECT_STREQ("foo", E.GetCStr(&offset));
	EXPECT_EQ(5U, offset);
	}

	TEST(DataExtractorTest, GetCStrEmpty) {
	uint8_t buffer[] = {'X', '\0'};
	DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

	lldb::offset_t offset = 1;
	EXPECT_STREQ("", E.GetCStr(&offset));
	EXPECT_EQ(2U, offset);
	}

	TEST(DataExtractorTest, GetCStrUnterminated) {
	uint8_t buffer[] = {'X', 'f', 'o', 'o'};
	DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

	lldb::offset_t offset = 1;
	EXPECT_EQ(nullptr, E.GetCStr(&offset));
	EXPECT_EQ(1U, offset);
	}

	TEST(DataExtractorTest, GetCStrAtEnd) {
	uint8_t buffer[] = {'X'};
	DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

	lldb::offset_t offset = 1;
	EXPECT_EQ(nullptr, E.GetCStr(&offset));
	EXPECT_EQ(1U, offset);
	}

	TEST(DataExtractorTest, GetCStrAtNullOffset) {
	uint8_t buffer[] = {'f', 'o', 'o', '\0'};
	DataExtractor E(buffer, sizeof buffer, lldb::eByteOrderLittle, 4);

	lldb::offset_t offset = 0;
	EXPECT_STREQ("foo", E.GetCStr(&offset));
	EXPECT_EQ(4U, offset);
	}

	TEST(DataExtractorTest, UncommonAddressSize) {
	uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
	DataExtractor E2(buffer, sizeof buffer, lldb::eByteOrderLittle, 2);
	DataExtractor E5(buffer, sizeof buffer, lldb::eByteOrderLittle, 5);
	DataExtractor E7(buffer, sizeof buffer, lldb::eByteOrderLittle, 7);

	lldb::offset_t offset;

	// Test 2-byte addresses (for AVR).
	offset = 0;
	EXPECT_EQ(0x0201U, E2.GetMaxU64(&offset, 2));
	EXPECT_EQ(2U, offset);
	offset = 0;
	EXPECT_EQ(0x0201U, E2.GetAddress(&offset));
	EXPECT_EQ(2U, offset);

	// Test 5-byte addresses.
	offset = 0;
	EXPECT_EQ(0x030201U, E5.GetMaxU64(&offset, 3));
	EXPECT_EQ(3U, offset);
	offset = 3;
	EXPECT_EQ(0x0807060504U, E5.GetAddress(&offset));
	EXPECT_EQ(8U, offset);

	// Test 7-byte addresses.
	offset = 0;
	EXPECT_EQ(0x0504030201U, E7.GetMaxU64(&offset, 5));
	EXPECT_EQ(5U, offset);
	offset = 0;
	EXPECT_EQ(0x07060504030201U, E7.GetAddress(&offset));
	EXPECT_EQ(7U, offset);
	}

	TEST(DataExtractorTest, GetMaxU64) {
	uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

	lldb::offset_t offset;

	// Check with the minimum allowed byte size.
	offset = 0;
	EXPECT_EQ(0x01U, LE.GetMaxU64(&offset, 1));
	EXPECT_EQ(1U, offset);
	offset = 0;
	EXPECT_EQ(0x01U, BE.GetMaxU64(&offset, 1));
	EXPECT_EQ(1U, offset);

	// Check with a non-zero offset.
	offset = 1;
	EXPECT_EQ(0x0302U, LE.GetMaxU64(&offset, 2));
	EXPECT_EQ(3U, offset);
	offset = 1;
	EXPECT_EQ(0x0203U, BE.GetMaxU64(&offset, 2));
	EXPECT_EQ(3U, offset);

	// Check with the byte size not being a multiple of 2.
	offset = 0;
	EXPECT_EQ(0x07060504030201U, LE.GetMaxU64(&offset, 7));
	EXPECT_EQ(7U, offset);
	offset = 0;
	EXPECT_EQ(0x01020304050607U, BE.GetMaxU64(&offset, 7));
	EXPECT_EQ(7U, offset);

	// Check with the maximum allowed byte size.
	offset = 0;
	EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64(&offset, 8));
	EXPECT_EQ(8U, offset);
	offset = 0;
	EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64(&offset, 8));
	EXPECT_EQ(8U, offset);
	}

	TEST(DataExtractorTest, GetMaxS64) {
	uint8_t buffer[] = {0x01, 0x02, 0x83, 0x04, 0x05, 0x06, 0x07, 0x08};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

	lldb::offset_t offset;

	// Check with the minimum allowed byte size.
	offset = 0;
	EXPECT_EQ(0x01, LE.GetMaxS64(&offset, 1));
	EXPECT_EQ(1U, offset);
	offset = 0;
	EXPECT_EQ(0x01, BE.GetMaxS64(&offset, 1));
	EXPECT_EQ(1U, offset);

	// Check that sign extension works correctly.
	offset = 0;
	int64_t value = LE.GetMaxS64(&offset, 3);
	EXPECT_EQ(0xffffffffff830201U, reinterpret_cast<uint64_t >(&value));
	EXPECT_EQ(3U, offset);
	offset = 2;
	value = BE.GetMaxS64(&offset, 3);
	EXPECT_EQ(0xffffffffff830405U, reinterpret_cast<uint64_t >(&value));
	EXPECT_EQ(5U, offset);

	// Check with the maximum allowed byte size.
	offset = 0;
	EXPECT_EQ(0x0807060504830201, LE.GetMaxS64(&offset, 8));
	EXPECT_EQ(8U, offset);
	offset = 0;
	EXPECT_EQ(0x0102830405060708, BE.GetMaxS64(&offset, 8));
	EXPECT_EQ(8U, offset);
	}

	TEST(DataExtractorTest, GetMaxU64_unchecked) {
	uint8_t buffer[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

	lldb::offset_t offset;

	// Check with the minimum allowed byte size.
	offset = 0;
	EXPECT_EQ(0x01U, LE.GetMaxU64_unchecked(&offset, 1));
	EXPECT_EQ(1U, offset);
	offset = 0;
	EXPECT_EQ(0x01U, BE.GetMaxU64_unchecked(&offset, 1));
	EXPECT_EQ(1U, offset);

	// Check with a non-zero offset.
	offset = 1;
	EXPECT_EQ(0x0302U, LE.GetMaxU64_unchecked(&offset, 2));
	EXPECT_EQ(3U, offset);
	offset = 1;
	EXPECT_EQ(0x0203U, BE.GetMaxU64_unchecked(&offset, 2));
	EXPECT_EQ(3U, offset);

	// Check with the byte size not being a multiple of 2.
	offset = 0;
	EXPECT_EQ(0x07060504030201U, LE.GetMaxU64_unchecked(&offset, 7));
	EXPECT_EQ(7U, offset);
	offset = 0;
	EXPECT_EQ(0x01020304050607U, BE.GetMaxU64_unchecked(&offset, 7));
	EXPECT_EQ(7U, offset);

	// Check with the maximum allowed byte size.
	offset = 0;
	EXPECT_EQ(0x0807060504030201U, LE.GetMaxU64_unchecked(&offset, 8));
	EXPECT_EQ(8U, offset);
	offset = 0;
	EXPECT_EQ(0x0102030405060708U, BE.GetMaxU64_unchecked(&offset, 8));
	EXPECT_EQ(8U, offset);
	}

	TEST(DataExtractorTest, GetSLEB128_bit63) {
	uint8_t buffer[] = {0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x7f};

	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

	lldb::offset_t offset;

	int64_t expected =
	0b1111111100000001111111000000011111110000000111111100000001111111;
	offset = 0;
	EXPECT_EQ(expected, LE.GetSLEB128(&offset));
	EXPECT_EQ(9U, offset);
	offset = 0;
	EXPECT_EQ(expected, BE.GetSLEB128(&offset));
	EXPECT_EQ(9U, offset);
	}

	TEST(DataExtractorTest, GetULEB128_bit63) {
	uint8_t buffer[] = {0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0xff, 0x80, 0x7f};

	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig, sizeof(void *));

	lldb::offset_t offset;

	uint64_t expected =
	0b0111111100000001111111000000011111110000000111111100000001111111;
	offset = 0;
	EXPECT_EQ(expected, LE.GetULEB128(&offset));
	EXPECT_EQ(9U, offset);
	offset = 0;
	EXPECT_EQ(expected, BE.GetULEB128(&offset));
	EXPECT_EQ(9U, offset);
	}

	TEST(DataExtractorTest, GetFloat) {
	float expected = 4.0f;
	lldb::offset_t offset;

	{
	uint8_t buffer[] = {0x00, 0x00, 0x80, 0x40};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));

	offset = 0;
	EXPECT_DOUBLE_EQ(expected, LE.GetFloat(&offset));
	EXPECT_EQ(4U, offset);
	}

	{
	uint8_t buffer[] = {0x40, 0x80, 0x00, 0x00};
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
	sizeof(void *));
	offset = 0;
	EXPECT_DOUBLE_EQ(expected, BE.GetFloat(&offset));
	EXPECT_EQ(4U, offset);
	}
	}

	TEST(DataExtractorTest, GetFloatUnaligned) {
	float expected = 4.0f;
	lldb::offset_t offset;

	{
	uint8_t buffer[] = {0x00, 0x00, 0x00, 0x80, 0x40};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));

	offset = 1;
	EXPECT_DOUBLE_EQ(expected, LE.GetFloat(&offset));
	EXPECT_EQ(5U, offset);
	}

	{
	uint8_t buffer[] = {0x00, 0x40, 0x80, 0x00, 0x00};
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
	sizeof(void *));
	offset = 1;
	EXPECT_DOUBLE_EQ(expected, BE.GetFloat(&offset));
	EXPECT_EQ(5U, offset);
	}
	}

	TEST(DataExtractorTest, GetDouble) {
	if (sizeof(double) != 8)
	return;

	double expected = 4.0f;
	lldb::offset_t offset;

	{
	uint8_t buffer[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x40};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));

	offset = 0;
	EXPECT_DOUBLE_EQ(expected, LE.GetDouble(&offset));
	EXPECT_EQ(8U, offset);
	}

	{
	uint8_t buffer[] = {0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
	sizeof(void *));
	offset = 0;
	EXPECT_DOUBLE_EQ(expected, BE.GetDouble(&offset));
	EXPECT_EQ(8U, offset);
	}
	}

	TEST(DataExtractorTest, GetDoubleUnaligned) {
	if (sizeof(double) != 8)
	return;

	float expected = 4.0f;
	lldb::offset_t offset;

	{
	uint8_t buffer[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x40};
	DataExtractor LE(buffer, sizeof(buffer), lldb::eByteOrderLittle,
	sizeof(void *));

	offset = 1;
	EXPECT_DOUBLE_EQ(expected, LE.GetDouble(&offset));
	EXPECT_EQ(9U, offset);
	}

	{
	uint8_t buffer[] = {0x00, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	DataExtractor BE(buffer, sizeof(buffer), lldb::eByteOrderBig,
	sizeof(void *));
	offset = 1;
	EXPECT_DOUBLE_EQ(expected, BE.GetDouble(&offset));
	EXPECT_EQ(9U, offset);
	}
	}