| /* |
| * Copyright (c) 2018, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 2 Clause License and |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| * was not distributed with this source code in the LICENSE file, you can |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| * Media Patent License 1.0 was not distributed with this source code in the |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
| */ |
| #include <stdint.h> |
| |
| #include "aom/aom_integer.h" |
| #include "third_party/googletest/src/googletest/include/gtest/gtest.h" |
| |
| namespace { |
| const uint64_t kMaximumLeb128CodedSize = 8; |
| const uint8_t kLeb128PadByte = 0x80; // Binary: 10000000 |
| const uint64_t kMaximumLeb128Value = 0xFFFFFFFFFFFFFF; // 2 ^ 56 - 1 |
| const uint32_t kSizeTestNumValues = 6; |
| const uint32_t kSizeTestExpectedSizes[kSizeTestNumValues] = { |
| 1, 1, 2, 3, 4, 5 |
| }; |
| const uint64_t kSizeTestInputs[kSizeTestNumValues] = { |
| 0, 0x7f, 0x3fff, 0x1fffff, 0xffffff, 0x10000000 |
| }; |
| } // namespace |
| |
| TEST(AomLeb128, DecodeTest) { |
| const size_t num_leb128_bytes = 3; |
| const uint8_t leb128_bytes[num_leb128_bytes] = { 0xE5, 0x8E, 0x26 }; |
| const uint64_t expected_value = 0x98765; // 624485 |
| const size_t expected_length = 3; |
| uint64_t value = ~0ULL; // make sure value is cleared by the function |
| size_t length; |
| ASSERT_EQ( |
| aom_uleb_decode(&leb128_bytes[0], num_leb128_bytes, &value, &length), 0); |
| ASSERT_EQ(expected_value, value); |
| ASSERT_EQ(expected_length, length); |
| |
| // Make sure the decoder stops on the last marked LEB128 byte. |
| aom_uleb_decode(&leb128_bytes[0], num_leb128_bytes + 1, &value, &length); |
| ASSERT_EQ(expected_value, value); |
| ASSERT_EQ(expected_length, length); |
| } |
| |
| TEST(AomLeb128, EncodeTest) { |
| const uint32_t test_value = 0x98765; // 624485 |
| const uint8_t expected_bytes[3] = { 0xE5, 0x8E, 0x26 }; |
| const size_t kWriteBufferSize = 4; |
| uint8_t write_buffer[kWriteBufferSize] = { 0 }; |
| size_t bytes_written = 0; |
| ASSERT_EQ(aom_uleb_encode(test_value, kWriteBufferSize, &write_buffer[0], |
| &bytes_written), |
| 0); |
| ASSERT_EQ(bytes_written, 3u); |
| for (size_t i = 0; i < bytes_written; ++i) { |
| ASSERT_EQ(write_buffer[i], expected_bytes[i]); |
| } |
| } |
| |
| TEST(AomLeb128, EncodeDecodeTest) { |
| const uint32_t value = 0x98765; // 624485 |
| const size_t kWriteBufferSize = 4; |
| uint8_t write_buffer[kWriteBufferSize] = { 0 }; |
| size_t bytes_written = 0; |
| ASSERT_EQ(aom_uleb_encode(value, kWriteBufferSize, &write_buffer[0], |
| &bytes_written), |
| 0); |
| ASSERT_EQ(bytes_written, 3u); |
| uint64_t decoded_value; |
| size_t decoded_length; |
| aom_uleb_decode(&write_buffer[0], bytes_written, &decoded_value, |
| &decoded_length); |
| ASSERT_EQ(value, decoded_value); |
| ASSERT_EQ(bytes_written, decoded_length); |
| } |
| |
| TEST(AomLeb128, FixedSizeEncodeTest) { |
| const uint32_t test_value = 0x123; |
| const uint8_t expected_bytes[4] = { 0xa3, 0x82, 0x80, 0x00 }; |
| const size_t kWriteBufferSize = 4; |
| uint8_t write_buffer[kWriteBufferSize] = { 0 }; |
| size_t bytes_written = 0; |
| ASSERT_EQ(0, aom_uleb_encode_fixed_size(test_value, kWriteBufferSize, |
| kWriteBufferSize, &write_buffer[0], |
| &bytes_written)); |
| ASSERT_EQ(kWriteBufferSize, bytes_written); |
| for (size_t i = 0; i < bytes_written; ++i) { |
| ASSERT_EQ(write_buffer[i], expected_bytes[i]); |
| } |
| } |
| |
| TEST(AomLeb128, FixedSizeEncodeDecodeTest) { |
| const uint32_t value = 0x1; |
| const size_t kWriteBufferSize = 4; |
| uint8_t write_buffer[kWriteBufferSize] = { 0 }; |
| size_t bytes_written = 0; |
| ASSERT_EQ( |
| aom_uleb_encode_fixed_size(value, kWriteBufferSize, kWriteBufferSize, |
| &write_buffer[0], &bytes_written), |
| 0); |
| ASSERT_EQ(bytes_written, 4u); |
| uint64_t decoded_value; |
| size_t decoded_length; |
| aom_uleb_decode(&write_buffer[0], bytes_written, &decoded_value, |
| &decoded_length); |
| ASSERT_EQ(value, decoded_value); |
| ASSERT_EQ(bytes_written, decoded_length); |
| } |
| |
| TEST(AomLeb128, SizeTest) { |
| for (size_t i = 0; i < kSizeTestNumValues; ++i) { |
| ASSERT_EQ(kSizeTestExpectedSizes[i], |
| aom_uleb_size_in_bytes(kSizeTestInputs[i])); |
| } |
| } |
| |
| TEST(AomLeb128, DecodeFailTest) { |
| // Input buffer containing what would be a valid 9 byte LEB128 encoded |
| // unsigned integer. |
| const uint8_t kAllPadBytesBuffer[kMaximumLeb128CodedSize + 1] = { |
| kLeb128PadByte, kLeb128PadByte, kLeb128PadByte, |
| kLeb128PadByte, kLeb128PadByte, kLeb128PadByte, |
| kLeb128PadByte, kLeb128PadByte, 0 |
| }; |
| uint64_t decoded_value; |
| |
| // Test that decode fails when result would be valid 9 byte integer. |
| ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer[0], kMaximumLeb128CodedSize + 1, |
| &decoded_value, NULL), |
| -1); |
| |
| // Test that encoded value missing terminator byte within available buffer |
| // range causes decode error. |
| ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer[0], kMaximumLeb128CodedSize, |
| &decoded_value, NULL), |
| -1); |
| |
| // Test that LEB128 input that decodes to a value larger than 32-bits fails. |
| uint8_t encode_buffer[kMaximumLeb128CodedSize] = { 0 }; |
| const uint64_t kTooLargeForDecode = static_cast<uint64_t>(UINT32_MAX) + 1; |
| ASSERT_GT(aom_uleb_size_in_bytes(kTooLargeForDecode), 4u); |
| size_t bytes_written = 0; |
| ASSERT_EQ(aom_uleb_encode(kTooLargeForDecode, kMaximumLeb128CodedSize, |
| &encode_buffer[0], &bytes_written), |
| 0); |
| size_t value_size = 0; |
| ASSERT_EQ(aom_uleb_decode(&encode_buffer[0], bytes_written, &decoded_value, |
| &value_size), |
| -1); |
| } |
| |
| TEST(AomLeb128, EncodeFailTest) { |
| const size_t kWriteBufferSize = 4; |
| const uint32_t kValidTestValue = 1; |
| uint8_t write_buffer[kWriteBufferSize] = { 0 }; |
| size_t coded_size = 0; |
| ASSERT_EQ( |
| aom_uleb_encode(kValidTestValue, kWriteBufferSize, NULL, &coded_size), |
| -1); |
| ASSERT_EQ(aom_uleb_encode(kValidTestValue, kWriteBufferSize, &write_buffer[0], |
| NULL), |
| -1); |
| |
| const uint32_t kValueOutOfRangeForBuffer = 0xFFFFFFFF; |
| ASSERT_EQ(aom_uleb_encode(kValueOutOfRangeForBuffer, kWriteBufferSize, |
| &write_buffer[0], &coded_size), |
| -1); |
| |
| const uint64_t kValueOutOfRange = kMaximumLeb128Value + 1; |
| ASSERT_EQ(aom_uleb_encode(kValueOutOfRange, kWriteBufferSize, |
| &write_buffer[0], &coded_size), |
| -1); |
| |
| const size_t kPadSizeOutOfRange = 5; |
| ASSERT_EQ(aom_uleb_encode_fixed_size(kValidTestValue, kWriteBufferSize, |
| kPadSizeOutOfRange, &write_buffer[0], |
| &coded_size), |
| -1); |
| } |