2 * Copyright (c) 2018, Alliance for Open Media. All rights reserved
4 * This source code is subject to the terms of the BSD 2 Clause License and
5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6 * was not distributed with this source code in the LICENSE file, you can
7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8 * Media Patent License 1.0 was not distributed with this source code in the
9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
12 #include "aom/aom_integer.h"
13 #include "third_party/googletest/src/googletest/include/gtest/gtest.h"
16 const uint64_t kMaximumLeb128CodedSize
= 8;
17 const uint8_t kLeb128PadByte
= 0x80; // Binary: 10000000
18 const uint64_t kMaximumLeb128Value
= UINT32_MAX
;
19 const uint32_t kSizeTestNumValues
= 6;
20 const uint32_t kSizeTestExpectedSizes
[kSizeTestNumValues
] = {
23 const uint64_t kSizeTestInputs
[kSizeTestNumValues
] = { 0, 0x7f,
25 0xffffff, 0x10000000 };
27 const uint8_t kOutOfRangeLeb128Value
[5] = { 0x80, 0x80, 0x80, 0x80,
28 0x10 }; // UINT32_MAX + 1
31 TEST(AomLeb128
, DecodeTest
) {
32 const size_t num_leb128_bytes
= 3;
33 const uint8_t leb128_bytes
[num_leb128_bytes
] = { 0xE5, 0x8E, 0x26 };
34 const uint64_t expected_value
= 0x98765; // 624485
35 const size_t expected_length
= 3;
36 uint64_t value
= ~0ULL; // make sure value is cleared by the function
39 aom_uleb_decode(&leb128_bytes
[0], num_leb128_bytes
, &value
, &length
), 0);
40 ASSERT_EQ(expected_value
, value
);
41 ASSERT_EQ(expected_length
, length
);
43 // Make sure the decoder stops on the last marked LEB128 byte.
44 aom_uleb_decode(&leb128_bytes
[0], num_leb128_bytes
+ 1, &value
, &length
);
45 ASSERT_EQ(expected_value
, value
);
46 ASSERT_EQ(expected_length
, length
);
49 TEST(AomLeb128
, EncodeTest
) {
50 const uint32_t test_value
= 0x98765; // 624485
51 const uint8_t expected_bytes
[3] = { 0xE5, 0x8E, 0x26 };
52 const size_t kWriteBufferSize
= 4;
53 uint8_t write_buffer
[kWriteBufferSize
] = { 0 };
54 size_t bytes_written
= 0;
55 ASSERT_EQ(aom_uleb_encode(test_value
, kWriteBufferSize
, &write_buffer
[0],
58 ASSERT_EQ(bytes_written
, 3u);
59 for (size_t i
= 0; i
< bytes_written
; ++i
) {
60 ASSERT_EQ(write_buffer
[i
], expected_bytes
[i
]);
64 TEST(AomLeb128
, EncodeDecodeTest
) {
65 const uint32_t value
= 0x98765; // 624485
66 const size_t kWriteBufferSize
= 4;
67 uint8_t write_buffer
[kWriteBufferSize
] = { 0 };
68 size_t bytes_written
= 0;
69 ASSERT_EQ(aom_uleb_encode(value
, kWriteBufferSize
, &write_buffer
[0],
72 ASSERT_EQ(bytes_written
, 3u);
73 uint64_t decoded_value
;
74 size_t decoded_length
;
75 aom_uleb_decode(&write_buffer
[0], bytes_written
, &decoded_value
,
77 ASSERT_EQ(value
, decoded_value
);
78 ASSERT_EQ(bytes_written
, decoded_length
);
81 TEST(AomLeb128
, FixedSizeEncodeTest
) {
82 const uint32_t test_value
= 0x123;
83 const uint8_t expected_bytes
[4] = { 0xa3, 0x82, 0x80, 0x00 };
84 const size_t kWriteBufferSize
= 4;
85 uint8_t write_buffer
[kWriteBufferSize
] = { 0 };
86 size_t bytes_written
= 0;
87 ASSERT_EQ(0, aom_uleb_encode_fixed_size(test_value
, kWriteBufferSize
,
88 kWriteBufferSize
, &write_buffer
[0],
90 ASSERT_EQ(kWriteBufferSize
, bytes_written
);
91 for (size_t i
= 0; i
< bytes_written
; ++i
) {
92 ASSERT_EQ(write_buffer
[i
], expected_bytes
[i
]);
96 TEST(AomLeb128
, FixedSizeEncodeDecodeTest
) {
97 const uint32_t value
= 0x1;
98 const size_t kWriteBufferSize
= 4;
99 uint8_t write_buffer
[kWriteBufferSize
] = { 0 };
100 size_t bytes_written
= 0;
102 aom_uleb_encode_fixed_size(value
, kWriteBufferSize
, kWriteBufferSize
,
103 &write_buffer
[0], &bytes_written
),
105 ASSERT_EQ(bytes_written
, 4u);
106 uint64_t decoded_value
;
107 size_t decoded_length
;
108 aom_uleb_decode(&write_buffer
[0], bytes_written
, &decoded_value
,
110 ASSERT_EQ(value
, decoded_value
);
111 ASSERT_EQ(bytes_written
, decoded_length
);
114 TEST(AomLeb128
, SizeTest
) {
115 for (size_t i
= 0; i
< kSizeTestNumValues
; ++i
) {
116 ASSERT_EQ(kSizeTestExpectedSizes
[i
],
117 aom_uleb_size_in_bytes(kSizeTestInputs
[i
]));
121 TEST(AomLeb128
, DecodeFailTest
) {
122 // Input buffer containing what would be a valid 9 byte LEB128 encoded
124 const uint8_t kAllPadBytesBuffer
[kMaximumLeb128CodedSize
+ 1] = {
125 kLeb128PadByte
, kLeb128PadByte
, kLeb128PadByte
,
126 kLeb128PadByte
, kLeb128PadByte
, kLeb128PadByte
,
127 kLeb128PadByte
, kLeb128PadByte
, 0
129 uint64_t decoded_value
;
131 // Test that decode fails when result would be valid 9 byte integer.
132 ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer
[0], kMaximumLeb128CodedSize
+ 1,
133 &decoded_value
, nullptr),
136 // Test that encoded value missing terminator byte within available buffer
137 // range causes decode error.
138 ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer
[0], kMaximumLeb128CodedSize
,
139 &decoded_value
, nullptr),
142 // Test that LEB128 input that decodes to a value larger than 32-bits fails.
143 size_t value_size
= 0;
144 ASSERT_EQ(aom_uleb_decode(&kOutOfRangeLeb128Value
[0],
145 sizeof(kOutOfRangeLeb128Value
), &decoded_value
,
150 TEST(AomLeb128
, EncodeFailTest
) {
151 const size_t kWriteBufferSize
= 4;
152 const uint32_t kValidTestValue
= 1;
153 uint8_t write_buffer
[kWriteBufferSize
] = { 0 };
154 size_t coded_size
= 0;
156 aom_uleb_encode(kValidTestValue
, kWriteBufferSize
, nullptr, &coded_size
),
158 ASSERT_EQ(aom_uleb_encode(kValidTestValue
, kWriteBufferSize
, &write_buffer
[0],
162 const uint32_t kValueOutOfRangeForBuffer
= 0xFFFFFFFF;
163 ASSERT_EQ(aom_uleb_encode(kValueOutOfRangeForBuffer
, kWriteBufferSize
,
164 &write_buffer
[0], &coded_size
),
167 const uint64_t kValueOutOfRange
= kMaximumLeb128Value
+ 1;
168 ASSERT_EQ(aom_uleb_encode(kValueOutOfRange
, kWriteBufferSize
,
169 &write_buffer
[0], &coded_size
),
172 const size_t kPadSizeOutOfRange
= 5;
173 ASSERT_EQ(aom_uleb_encode_fixed_size(kValidTestValue
, kWriteBufferSize
,
174 kPadSizeOutOfRange
, &write_buffer
[0],