1 /*
2 * Copyright (c) 2024, Alliance for Open Media. All rights reserved
3 *
4 * This source code is subject to the terms of the BSD 3-Clause Clear License
5 * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
6 * License was not distributed with this source code in the LICENSE file, you
7 * can obtain it at www.aomedia.org/license/software-license/bsd-3-c-c. If the
8 * Alliance for Open Media Patent License 1.0 was not distributed with this
9 * source code in the PATENTS file, you can obtain it at
10 * www.aomedia.org/license/patent.
11 */
12 #include <sys/types.h>
13
14 #include <cstdint>
15
16 #include "absl/types/span.h"
17 #include "fuzztest/fuzztest.h"
18 #include "gtest/gtest.h"
19 #include "iamf/common/write_bit_buffer.h"
20
21 namespace iamf_tools {
22 namespace {
23
WriteSignedLiteral(uint32_t data,int num_bits)24 void WriteSignedLiteral(uint32_t data, int num_bits) {
25 WriteBitBuffer wb(0);
26 auto status = wb.WriteUnsignedLiteral(data, num_bits);
27 if (status.ok()) {
28 EXPECT_EQ(wb.bit_offset(), num_bits);
29 } else {
30 EXPECT_EQ(wb.bit_offset(), 0);
31 }
32 }
33
34 FUZZ_TEST(WriteBitBufferFuzzTest, WriteSignedLiteral);
35
WriteSignedLiteral64(uint64_t data,int num_bits)36 void WriteSignedLiteral64(uint64_t data, int num_bits) {
37 WriteBitBuffer wb(0);
38 auto status = wb.WriteUnsignedLiteral(data, num_bits);
39 if (status.ok()) {
40 EXPECT_EQ(wb.bit_offset(), num_bits);
41 } else {
42 EXPECT_EQ(wb.bit_offset(), 0);
43 }
44 }
45
46 FUZZ_TEST(WriteBitBufferFuzzTest, WriteSignedLiteral64);
47
WriteSigned8(int8_t data)48 void WriteSigned8(int8_t data) {
49 WriteBitBuffer wb(0);
50 auto status = wb.WriteSigned8(data);
51 if (status.ok()) {
52 EXPECT_EQ(wb.bit_offset(), 8);
53 } else {
54 EXPECT_EQ(wb.bit_offset(), 0);
55 }
56 }
57
58 FUZZ_TEST(WriteBitBufferFuzzTest, WriteSigned8);
59
WriteSigned16(int16_t data)60 void WriteSigned16(int16_t data) {
61 WriteBitBuffer wb(0);
62 auto status = wb.WriteSigned16(data);
63 if (status.ok()) {
64 EXPECT_EQ(wb.bit_offset(), 16);
65 } else {
66 EXPECT_EQ(wb.bit_offset(), 0);
67 }
68 }
69
70 FUZZ_TEST(WriteBitBufferFuzzTest, WriteSigned16);
71
WriteStringAndValidate(const std::string & data)72 void WriteStringAndValidate(const std::string& data) {
73 WriteBitBuffer wb(0);
74 auto status = wb.WriteString(data);
75 if (status.ok()) {
76 const auto number_of_bytes =
77 data.size() + 1; // +1 for the NULL terminator.
78 const auto number_of_bits = number_of_bytes * 8;
79 EXPECT_EQ(wb.bit_offset(), number_of_bits);
80 std::vector<uint8_t> expected_data = {data.begin(), data.end()};
81 expected_data.push_back(0); // NULL terminator.
82 EXPECT_EQ(wb.bit_buffer(), expected_data);
83 } else {
84 EXPECT_EQ(wb.bit_offset(), 0);
85 }
86 }
87
88 FUZZ_TEST(WriteBitBufferFuzzTest, WriteStringAndValidate);
89
WriteUint8Span(const std::vector<uint8_t> & data)90 void WriteUint8Span(const std::vector<uint8_t>& data) {
91 WriteBitBuffer wb(0);
92 auto status = wb.WriteUint8Span(absl::MakeConstSpan(data));
93 if (status.ok()) {
94 EXPECT_EQ(wb.bit_offset(), data.size() * 8);
95 EXPECT_EQ(wb.bit_buffer(), data);
96 } else {
97 EXPECT_EQ(wb.bit_offset(), 0);
98 }
99 }
100
101 FUZZ_TEST(WriteBitBufferFuzzTest, WriteUint8Span);
102
WriteUleb128(uint32_t data)103 void WriteUleb128(uint32_t data) {
104 WriteBitBuffer wb(0);
105 auto status = wb.WriteUleb128(data);
106 if (status.ok()) {
107 EXPECT_NE(wb.bit_offset(), 0);
108 } else {
109 EXPECT_EQ(wb.bit_offset(), 0);
110 }
111 }
112
113 FUZZ_TEST(WriteBitBufferFuzzTest, WriteUleb128);
114
WriteIso14496_1Expanded(uint32_t data)115 void WriteIso14496_1Expanded(uint32_t data) {
116 WriteBitBuffer wb(0);
117 auto status = wb.WriteIso14496_1Expanded(data);
118 if (status.ok()) {
119 EXPECT_NE(wb.bit_offset(), 0);
120 } else {
121 EXPECT_EQ(wb.bit_offset(), 0);
122 }
123 }
124
125 FUZZ_TEST(WriteBitBufferFuzzTest, WriteIso14496_1Expanded);
126
127 } // namespace
128 } // namespace iamf_tools
129