1 /*
2 * Copyright (c) 2023, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 3-Clause Clear
5 * License and the Alliance for Open Media Patent License 1.0. If the BSD
6 * 3-Clause Clear License was not distributed with this source code in the
7 * LICENSE file, you can obtain it at
8 * www.aomedia.org/license/software-license/bsd-3-c-c. If the Alliance for
9 * Open Media Patent License 1.0 was not distributed with this source code
10 * in the PATENTS file, you can obtain it at www.aomedia.org/license/patent.
11 */
12 #include "iamf/common/leb_generator.h"
13
14 #include <cstdint>
15 #include <limits>
16 #include <memory>
17 #include <vector>
18
19 #include "absl/status/status.h"
20 #include "absl/status/status_matchers.h"
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23 #include "iamf/obu/types.h"
24
25 namespace iamf_tools {
26 namespace {
27
28 using ::absl_testing::IsOk;
29
30 class LebGeneratorTest : public testing::Test {
31 public:
32 LebGeneratorTest() = default;
33
TestUleb128ToUint8Vector(DecodedUleb128 input,std::vector<uint8_t> expected_result,absl::StatusCode expected_status_code=absl::StatusCode::kOk)34 void TestUleb128ToUint8Vector(
35 DecodedUleb128 input, std::vector<uint8_t> expected_result,
36 absl::StatusCode expected_status_code = absl::StatusCode::kOk) {
37 EXPECT_NE(leb_generator_, nullptr);
38
39 std::vector<uint8_t> output_buffer;
40 EXPECT_EQ(leb_generator_->Uleb128ToUint8Vector(input, output_buffer).code(),
41 expected_status_code);
42 if (expected_status_code == absl::StatusCode::kOk) {
43 EXPECT_EQ(output_buffer, expected_result);
44 }
45 }
46
TestSleb128ToUint8Vector(DecodedSleb128 input,std::vector<uint8_t> expected_result,absl::StatusCode expected_status_code=absl::StatusCode::kOk)47 void TestSleb128ToUint8Vector(
48 DecodedSleb128 input, std::vector<uint8_t> expected_result,
49 absl::StatusCode expected_status_code = absl::StatusCode::kOk) {
50 EXPECT_NE(leb_generator_, nullptr);
51
52 std::vector<uint8_t> output_buffer;
53 EXPECT_EQ(leb_generator_->Sleb128ToUint8Vector(input, output_buffer).code(),
54 expected_status_code);
55 if (expected_status_code == absl::StatusCode::kOk) {
56 EXPECT_EQ(output_buffer, expected_result);
57 }
58 }
59
60 protected:
61 std::unique_ptr<LebGenerator> leb_generator_ = LebGenerator::Create();
62 };
63
TEST_F(LebGeneratorTest,MinimalUlebZero)64 TEST_F(LebGeneratorTest, MinimalUlebZero) {
65 TestUleb128ToUint8Vector(/*input=*/0, {0});
66 }
67
TEST_F(LebGeneratorTest,MinimalUlebMaxValueOneByte)68 TEST_F(LebGeneratorTest, MinimalUlebMaxValueOneByte) {
69 TestUleb128ToUint8Vector(/*input=*/127, {127});
70 }
71
TEST_F(LebGeneratorTest,MinimalUlebMinValueTwoBytes)72 TEST_F(LebGeneratorTest, MinimalUlebMinValueTwoBytes) {
73 TestUleb128ToUint8Vector(/*input=*/128, {0x80, 0x01});
74 }
75
TEST_F(LebGeneratorTest,MinimalUlebMaxValueFourBytes)76 TEST_F(LebGeneratorTest, MinimalUlebMaxValueFourBytes) {
77 TestUleb128ToUint8Vector(/*input=*/(1 << 28) - 1, {0xff, 0xff, 0xff, 0x7f});
78 }
79
TEST_F(LebGeneratorTest,MinimalUlebMinValueFiveBytes)80 TEST_F(LebGeneratorTest, MinimalUlebMinValueFiveBytes) {
81 TestUleb128ToUint8Vector(/*input=*/(1 << 28), {0x80, 0x80, 0x80, 0x80, 0x01});
82 }
83
TEST_F(LebGeneratorTest,MinimalUlebMaxInputValue)84 TEST_F(LebGeneratorTest, MinimalUlebMaxInputValue) {
85 TestUleb128ToUint8Vector(/*input=*/std::numeric_limits<DecodedUleb128>::max(),
86 {0xff, 0xff, 0xff, 0xff, 0x0f});
87 }
88
TEST_F(LebGeneratorTest,UlebFixedSizeOne)89 TEST_F(LebGeneratorTest, UlebFixedSizeOne) {
90 leb_generator_ =
91 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 1);
92
93 TestUleb128ToUint8Vector(/*input=*/0, {0});
94 }
95
TEST_F(LebGeneratorTest,UlebFixedSizeFive)96 TEST_F(LebGeneratorTest, UlebFixedSizeFive) {
97 leb_generator_ =
98 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 5);
99
100 TestUleb128ToUint8Vector(/*input=*/0, {0x80, 0x80, 0x80, 0x80, 0x00});
101 }
102
TEST_F(LebGeneratorTest,UlebFixedSizeEight)103 TEST_F(LebGeneratorTest, UlebFixedSizeEight) {
104 leb_generator_ =
105 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 8);
106
107 TestUleb128ToUint8Vector(/*input=*/0,
108 {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00});
109 }
110
TEST_F(LebGeneratorTest,IllegalUlebFixedSizeOneTooSmall)111 TEST_F(LebGeneratorTest, IllegalUlebFixedSizeOneTooSmall) {
112 leb_generator_ =
113 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 1);
114
115 TestUleb128ToUint8Vector(/*input=*/128, {},
116 absl::StatusCode::kInvalidArgument);
117 }
118
TEST_F(LebGeneratorTest,MinimalSlebZero)119 TEST_F(LebGeneratorTest, MinimalSlebZero) {
120 TestSleb128ToUint8Vector(/*input=*/0, {0});
121 }
122
TEST_F(LebGeneratorTest,MinimalSlebMinPositive)123 TEST_F(LebGeneratorTest, MinimalSlebMinPositive) {
124 TestSleb128ToUint8Vector(/*input=*/1, {0x01});
125 }
126
TEST_F(LebGeneratorTest,MinimalSlebMaxPositiveValueOneByte)127 TEST_F(LebGeneratorTest, MinimalSlebMaxPositiveValueOneByte) {
128 TestSleb128ToUint8Vector(/*input=*/63, {63});
129 }
130
TEST_F(LebGeneratorTest,MinimalSlebMinPositiveValueTwoBytes)131 TEST_F(LebGeneratorTest, MinimalSlebMinPositiveValueTwoBytes) {
132 TestSleb128ToUint8Vector(/*input=*/64, {0xc0, 0x00});
133 }
134
TEST_F(LebGeneratorTest,MinimalSlebMaxPositiveValueFourBytes)135 TEST_F(LebGeneratorTest, MinimalSlebMaxPositiveValueFourBytes) {
136 TestSleb128ToUint8Vector(/*input=*/(1 << 27) - 1, {0xff, 0xff, 0xff, 0x3f});
137 }
138
TEST_F(LebGeneratorTest,MinimalSlebMinPositiveValueFiveBytes)139 TEST_F(LebGeneratorTest, MinimalSlebMinPositiveValueFiveBytes) {
140 TestSleb128ToUint8Vector(/*input=*/(1 << 27), {0x80, 0x80, 0x80, 0xc0, 0x00});
141 }
142
TEST_F(LebGeneratorTest,MinimalSlebMaxPositiveInputValue)143 TEST_F(LebGeneratorTest, MinimalSlebMaxPositiveInputValue) {
144 TestSleb128ToUint8Vector(/*input=*/std::numeric_limits<DecodedSleb128>::max(),
145 {0xff, 0xff, 0xff, 0xff, 0x07});
146 }
147
TEST_F(LebGeneratorTest,MinimalSlebMinNegativeInputValue)148 TEST_F(LebGeneratorTest, MinimalSlebMinNegativeInputValue) {
149 TestSleb128ToUint8Vector(/*input=*/std::numeric_limits<DecodedSleb128>::min(),
150 {0x80, 0x80, 0x80, 0x80, 0x78});
151 }
152
TEST_F(LebGeneratorTest,MinimalSlebMinNegativeValueFourBytes)153 TEST_F(LebGeneratorTest, MinimalSlebMinNegativeValueFourBytes) {
154 TestSleb128ToUint8Vector(/*input=*/-(1 << 27), {0x80, 0x80, 0x80, 0x40});
155 }
156
TEST_F(LebGeneratorTest,MinimalSlebMaxNegativeValueFiveBytes)157 TEST_F(LebGeneratorTest, MinimalSlebMaxNegativeValueFiveBytes) {
158 TestSleb128ToUint8Vector(/*input=*/(-(1 << 27)) - 1,
159 {0xff, 0xff, 0xff, 0xbf, 0x7f});
160 }
161
TEST_F(LebGeneratorTest,MinimalSlebMaxNegativeInputValue)162 TEST_F(LebGeneratorTest, MinimalSlebMaxNegativeInputValue) {
163 TestSleb128ToUint8Vector(/*input=*/-1, {0x7f});
164 }
165
TEST_F(LebGeneratorTest,SlebFixedSizeOne)166 TEST_F(LebGeneratorTest, SlebFixedSizeOne) {
167 leb_generator_ =
168 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 1);
169
170 TestSleb128ToUint8Vector(/*input=*/0, {0});
171 }
172
TEST_F(LebGeneratorTest,SlebFixedSizeFive)173 TEST_F(LebGeneratorTest, SlebFixedSizeFive) {
174 leb_generator_ =
175 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 5);
176
177 TestSleb128ToUint8Vector(/*input=*/0, {0x80, 0x80, 0x80, 0x80, 0x00});
178 }
179
TEST_F(LebGeneratorTest,SlebFixedSizeEight)180 TEST_F(LebGeneratorTest, SlebFixedSizeEight) {
181 leb_generator_ =
182 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 8);
183
184 TestSleb128ToUint8Vector(/*input=*/0,
185 {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00});
186 }
187
TEST_F(LebGeneratorTest,SlebFixedSizeOneTooSmall)188 TEST_F(LebGeneratorTest, SlebFixedSizeOneTooSmall) {
189 leb_generator_ =
190 LebGenerator::Create(LebGenerator::GenerationMode::kFixedSize, 1);
191
192 TestSleb128ToUint8Vector(/*input=*/64, {},
193 absl::StatusCode::kInvalidArgument);
194 }
195
196 struct Uleb128MinSizeTestCase {
197 DecodedUleb128 decoded_uleb128;
198 int8_t expected_size;
199 };
200
201 class LebGeneratorTestForUleb128MinSize
202 : public testing::TestWithParam<Uleb128MinSizeTestCase> {};
203
TEST_P(LebGeneratorTestForUleb128MinSize,Uleb128ToUint8VectorOutputSize)204 TEST_P(LebGeneratorTestForUleb128MinSize, Uleb128ToUint8VectorOutputSize) {
205 std::vector<uint8_t> output_buffer;
206 EXPECT_THAT(LebGenerator::Create()->Uleb128ToUint8Vector(
207 GetParam().decoded_uleb128, output_buffer),
208 IsOk());
209 EXPECT_EQ(output_buffer.size(), GetParam().expected_size);
210 }
211
212 INSTANTIATE_TEST_SUITE_P(Zero, LebGeneratorTestForUleb128MinSize,
213 testing::ValuesIn<Uleb128MinSizeTestCase>({{0, 1}}));
214
215 INSTANTIATE_TEST_SUITE_P(Max, LebGeneratorTestForUleb128MinSize,
216 testing::ValuesIn<Uleb128MinSizeTestCase>(
217 {{std::numeric_limits<DecodedUleb128>::max(),
218 5}}));
219
220 INSTANTIATE_TEST_SUITE_P(EdgeCases, LebGeneratorTestForUleb128MinSize,
221 testing::ValuesIn<Uleb128MinSizeTestCase>({
222 {(1l << 7) - 1, 1},
223 {(1l << 7), 2},
224 {(1l << 14) - 1, 2},
225 {(1l << 14), 3},
226 {(1l << 21) - 1, 3},
227 {(1l << 21), 4},
228 {(1l << 28) - 1, 4},
229 {(1l << 28), 5},
230 }));
231
232 struct Sleb128MinSizeTestCase {
233 DecodedSleb128 decoded_sleb128;
234 int8_t expected_size;
235 };
236
237 class LebGeneratorTestForSleb128MinSize
238 : public testing::TestWithParam<Sleb128MinSizeTestCase> {};
239
TEST_P(LebGeneratorTestForSleb128MinSize,Sleb128ToUint8VectorOutputSize)240 TEST_P(LebGeneratorTestForSleb128MinSize, Sleb128ToUint8VectorOutputSize) {
241 std::vector<uint8_t> output_buffer;
242 EXPECT_THAT(LebGenerator::Create()->Sleb128ToUint8Vector(
243 GetParam().decoded_sleb128, output_buffer),
244 IsOk());
245 EXPECT_EQ(output_buffer.size(), GetParam().expected_size);
246 }
247
248 INSTANTIATE_TEST_SUITE_P(Zero, LebGeneratorTestForSleb128MinSize,
249 testing::ValuesIn<Sleb128MinSizeTestCase>({{0, 1}}));
250
251 INSTANTIATE_TEST_SUITE_P(Max, LebGeneratorTestForSleb128MinSize,
252 testing::ValuesIn<Sleb128MinSizeTestCase>({
253 {std::numeric_limits<DecodedSleb128>::max(), 5},
254 }));
255
256 INSTANTIATE_TEST_SUITE_P(Min, LebGeneratorTestForSleb128MinSize,
257 testing::ValuesIn<Sleb128MinSizeTestCase>({
258 {std::numeric_limits<DecodedSleb128>::min(), 5},
259 }));
260
261 INSTANTIATE_TEST_SUITE_P(PositiveEdgeCases, LebGeneratorTestForSleb128MinSize,
262 testing::ValuesIn<Sleb128MinSizeTestCase>({
263 {(1 << 6) - 1, 1},
264 {(1 << 6), 2},
265 {(1 << 13) - 1, 2},
266 {(1 << 13), 3},
267 {(1 << 20) - 1, 3},
268 {(1 << 20), 4},
269 {(1 << 27) - 1, 4},
270 {(1 << 27), 5},
271 }));
272
273 INSTANTIATE_TEST_SUITE_P(NegativeEdgeCases, LebGeneratorTestForSleb128MinSize,
274 testing::ValuesIn<Sleb128MinSizeTestCase>({
275 {-(1 << 6), 1},
276 {-(1 << 6) - 1, 2},
277 {-(1 << 13), 2},
278 {-(1 << 13) - 1, 3},
279 {-(1 << 20), 3},
280 {-(1 << 20) - 1, 4},
281 {-(1 << 27), 4},
282 {-(1 << 27) - 1, 5},
283 }));
284
285 } // namespace
286 } // namespace iamf_tools
287