gecko-dev/third_party/aom/test/aom_integer_test.cc

178 строки
6.5 KiB
C++

/*
* 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 "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 = UINT32_MAX;
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
};
const uint8_t kOutOfRangeLeb128Value[5] = { 0x80, 0x80, 0x80, 0x80,
0x10 }; // UINT32_MAX + 1
} // 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.
size_t value_size = 0;
ASSERT_EQ(aom_uleb_decode(&kOutOfRangeLeb128Value[0],
sizeof(kOutOfRangeLeb128Value), &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);
}