1 /*
2  * Copyright (c) 2009-2021, Google LLC
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  *     * Redistributions of source code must retain the above copyright
8  *       notice, this list of conditions and the following disclaimer.
9  *     * Redistributions in binary form must reproduce the above copyright
10  *       notice, this list of conditions and the following disclaimer in the
11  *       documentation and/or other materials provided with the distribution.
12  *     * Neither the name of Google LLC nor the
13  *       names of its contributors may be used to endorse or promote products
14  *       derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY DIRECT,
20  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #include <string_view>
29 #include <vector>
30 
31 #include "gmock/gmock.h"
32 #include "gtest/gtest.h"
33 #include "absl/container/flat_hash_set.h"
34 #include "google/protobuf/descriptor.h"
35 #include "upb/message/internal.h"
36 #include "upb/mini_table/common_internal.h"
37 #include "upb/mini_table/decode.h"
38 #include "upb/mini_table/encode_internal.hpp"
39 #include "upb/mini_table/enum_internal.h"
40 #include "upb/upb.hpp"
41 #include "upb/wire/decode.h"
42 
43 // begin:google_only
44 // #include "testing/fuzzing/fuzztest.h"
45 // end:google_only
46 
47 namespace protobuf = ::google::protobuf;
48 
49 class MiniTableTest : public testing::TestWithParam<upb_MiniTablePlatform> {};
50 
TEST_P(MiniTableTest,Empty)51 TEST_P(MiniTableTest, Empty) {
52   upb::Arena arena;
53   upb::Status status;
54   upb_MiniTable* table =
55       _upb_MiniTable_Build(NULL, 0, GetParam(), arena.ptr(), status.ptr());
56   ASSERT_NE(nullptr, table);
57   EXPECT_EQ(0, table->field_count);
58   EXPECT_EQ(0, table->required_count);
59 }
60 
TEST_P(MiniTableTest,AllScalarTypes)61 TEST_P(MiniTableTest, AllScalarTypes) {
62   upb::Arena arena;
63   upb::MtDataEncoder e;
64   ASSERT_TRUE(e.StartMessage(0));
65   int count = 0;
66   for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
67     ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i, 0));
68     count++;
69   }
70   upb::Status status;
71   upb_MiniTable* table = _upb_MiniTable_Build(
72       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
73   ASSERT_NE(nullptr, table);
74   EXPECT_EQ(count, table->field_count);
75   absl::flat_hash_set<size_t> offsets;
76   for (int i = 0; i < 16; i++) {
77     const upb_MiniTableField* f = &table->fields[i];
78     EXPECT_EQ(i + 1, f->number);
79     EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
80     EXPECT_TRUE(offsets.insert(f->offset).second);
81     EXPECT_TRUE(f->offset < table->size);
82   }
83   EXPECT_EQ(0, table->required_count);
84 }
85 
TEST_P(MiniTableTest,AllRepeatedTypes)86 TEST_P(MiniTableTest, AllRepeatedTypes) {
87   upb::Arena arena;
88   upb::MtDataEncoder e;
89   ASSERT_TRUE(e.StartMessage(0));
90   int count = 0;
91   for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
92     ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i,
93                            kUpb_FieldModifier_IsRepeated));
94     count++;
95   }
96   upb::Status status;
97   upb_MiniTable* table = _upb_MiniTable_Build(
98       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
99   ASSERT_NE(nullptr, table);
100   EXPECT_EQ(count, table->field_count);
101   absl::flat_hash_set<size_t> offsets;
102   for (int i = 0; i < 16; i++) {
103     const upb_MiniTableField* f = &table->fields[i];
104     EXPECT_EQ(i + 1, f->number);
105     EXPECT_EQ(kUpb_FieldMode_Array, f->mode & kUpb_FieldMode_Mask);
106     EXPECT_TRUE(offsets.insert(f->offset).second);
107     EXPECT_TRUE(f->offset < table->size);
108   }
109   EXPECT_EQ(0, table->required_count);
110 }
111 
TEST_P(MiniTableTest,Skips)112 TEST_P(MiniTableTest, Skips) {
113   upb::Arena arena;
114   upb::MtDataEncoder e;
115   ASSERT_TRUE(e.StartMessage(0));
116   int count = 0;
117   std::vector<int> field_numbers;
118   for (int i = 0; i < 25; i++) {
119     int field_number = 1 << i;
120     field_numbers.push_back(field_number);
121     ASSERT_TRUE(e.PutField(kUpb_FieldType_Float, field_number, 0));
122     count++;
123   }
124   upb::Status status;
125   upb_MiniTable* table = _upb_MiniTable_Build(
126       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
127   ASSERT_NE(nullptr, table);
128   EXPECT_EQ(count, table->field_count);
129   absl::flat_hash_set<size_t> offsets;
130   for (size_t i = 0; i < field_numbers.size(); i++) {
131     const upb_MiniTableField* f = &table->fields[i];
132     EXPECT_EQ(field_numbers[i], f->number);
133     EXPECT_EQ(kUpb_FieldType_Float, upb_MiniTableField_Type(f));
134     EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
135     EXPECT_TRUE(offsets.insert(f->offset).second);
136     EXPECT_TRUE(f->offset < table->size);
137   }
138   EXPECT_EQ(0, table->required_count);
139 }
140 
TEST_P(MiniTableTest,AllScalarTypesOneof)141 TEST_P(MiniTableTest, AllScalarTypesOneof) {
142   upb::Arena arena;
143   upb::MtDataEncoder e;
144   ASSERT_TRUE(e.StartMessage(0));
145   int count = 0;
146   for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
147     ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i, 0));
148     count++;
149   }
150   ASSERT_TRUE(e.StartOneof());
151   for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
152     ASSERT_TRUE(e.PutOneofField(i));
153   }
154   upb::Status status;
155   upb_MiniTable* table = _upb_MiniTable_Build(
156       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
157   ASSERT_NE(nullptr, table) << status.error_message();
158   EXPECT_EQ(count, table->field_count);
159   absl::flat_hash_set<size_t> offsets;
160   for (int i = 0; i < 16; i++) {
161     const upb_MiniTableField* f = &table->fields[i];
162     EXPECT_EQ(i + 1, f->number);
163     EXPECT_EQ(kUpb_FieldMode_Scalar, f->mode & kUpb_FieldMode_Mask);
164     // For a oneof all fields have the same offset.
165     EXPECT_EQ(table->fields[0].offset, f->offset);
166     // All presence fields should point to the same oneof case offset.
167     size_t case_ofs = _upb_oneofcase_ofs(f);
168     EXPECT_EQ(table->fields[0].presence, f->presence);
169     EXPECT_TRUE(f->offset < table->size);
170     EXPECT_TRUE(case_ofs < table->size);
171     EXPECT_TRUE(case_ofs != f->offset);
172   }
173   EXPECT_EQ(0, table->required_count);
174 }
175 
TEST_P(MiniTableTest,SizeOverflow)176 TEST_P(MiniTableTest, SizeOverflow) {
177   upb::Arena arena;
178   upb::MtDataEncoder e;
179   // upb can only handle messages up to UINT16_MAX.
180   size_t max_double_fields = UINT16_MAX / (sizeof(double) + 1);
181 
182   // A bit under max_double_fields is ok.
183   ASSERT_TRUE(e.StartMessage(0));
184   for (size_t i = 1; i < max_double_fields; i++) {
185     ASSERT_TRUE(e.PutField(kUpb_FieldType_Double, i, 0));
186   }
187   upb::Status status;
188   upb_MiniTable* table = _upb_MiniTable_Build(
189       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
190   ASSERT_NE(nullptr, table) << status.error_message();
191 
192   // A bit over max_double_fields fails.
193   ASSERT_TRUE(e.StartMessage(0));
194   for (size_t i = 1; i < max_double_fields + 2; i++) {
195     ASSERT_TRUE(e.PutField(kUpb_FieldType_Double, i, 0));
196   }
197   upb_MiniTable* table2 = _upb_MiniTable_Build(
198       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
199   ASSERT_EQ(nullptr, table2) << status.error_message();
200 }
201 
202 INSTANTIATE_TEST_SUITE_P(Platforms, MiniTableTest,
203                          testing::Values(kUpb_MiniTablePlatform_32Bit,
204                                          kUpb_MiniTablePlatform_64Bit));
205 
TEST(MiniTablePlatformIndependentTest,Base92Roundtrip)206 TEST(MiniTablePlatformIndependentTest, Base92Roundtrip) {
207   for (char i = 0; i < 92; i++) {
208     EXPECT_EQ(i, _upb_FromBase92(_upb_ToBase92(i)));
209   }
210 }
211 
TEST(MiniTablePlatformIndependentTest,IsTypePackable)212 TEST(MiniTablePlatformIndependentTest, IsTypePackable) {
213   for (int i = 1; i <= protobuf::FieldDescriptor::MAX_TYPE; i++) {
214     EXPECT_EQ(upb_FieldType_IsPackable(static_cast<upb_FieldType>(i)),
215               protobuf::FieldDescriptor::IsTypePackable(
216                   static_cast<protobuf::FieldDescriptor::Type>(i)));
217   }
218 }
219 
TEST(MiniTableEnumTest,Enum)220 TEST(MiniTableEnumTest, Enum) {
221   upb::Arena arena;
222   upb::MtDataEncoder e;
223 
224   ASSERT_TRUE(e.StartEnum());
225   absl::flat_hash_set<int32_t> values;
226   for (int i = 0; i < 256; i++) {
227     values.insert(i * 2);
228     e.PutEnumValue(i * 2);
229   }
230   e.EndEnum();
231 
232   upb::Status status;
233   upb_MiniTableEnum* table = upb_MiniTableEnum_Build(
234       e.data().data(), e.data().size(), arena.ptr(), status.ptr());
235   ASSERT_NE(nullptr, table) << status.error_message();
236 
237   for (int i = 0; i < UINT16_MAX; i++) {
238     EXPECT_EQ(values.contains(i), upb_MiniTableEnum_CheckValue(table, i)) << i;
239   }
240 }
241 
TEST_P(MiniTableTest,SubsInitializedToNull)242 TEST_P(MiniTableTest, SubsInitializedToNull) {
243   upb::Arena arena;
244   upb::MtDataEncoder e;
245   // Create mini table with 2 message fields.
246   ASSERT_TRUE(e.StartMessage(0));
247   ASSERT_TRUE(e.PutField(kUpb_FieldType_Message, 15, 0));
248   ASSERT_TRUE(e.PutField(kUpb_FieldType_Message, 16, 0));
249   upb::Status status;
250   upb_MiniTable* table = _upb_MiniTable_Build(
251       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
252   ASSERT_NE(nullptr, table);
253   EXPECT_EQ(table->field_count, 2);
254   EXPECT_EQ(table->subs[0].submsg, nullptr);
255   EXPECT_EQ(table->subs[1].submsg, nullptr);
256 }
257 
TEST(MiniTableEnumTest,PositiveAndNegative)258 TEST(MiniTableEnumTest, PositiveAndNegative) {
259   upb::Arena arena;
260   upb::MtDataEncoder e;
261 
262   ASSERT_TRUE(e.StartEnum());
263   absl::flat_hash_set<int32_t> values;
264   for (int i = 0; i < 100; i++) {
265     values.insert(i);
266     e.PutEnumValue(i);
267   }
268   for (int i = 100; i > 0; i--) {
269     values.insert(-i);
270     e.PutEnumValue(-i);
271   }
272   e.EndEnum();
273 
274   upb::Status status;
275   upb_MiniTableEnum* table = upb_MiniTableEnum_Build(
276       e.data().data(), e.data().size(), arena.ptr(), status.ptr());
277   ASSERT_NE(nullptr, table) << status.error_message();
278 
279   for (int i = -UINT16_MAX; i < UINT16_MAX; i++) {
280     EXPECT_EQ(values.contains(i), upb_MiniTableEnum_CheckValue(table, i)) << i;
281   }
282 }
283 
TEST_P(MiniTableTest,Extendible)284 TEST_P(MiniTableTest, Extendible) {
285   upb::Arena arena;
286   upb::MtDataEncoder e;
287   ASSERT_TRUE(e.StartMessage(kUpb_MessageModifier_IsExtendable));
288   int count = 0;
289   for (int i = kUpb_FieldType_Double; i < kUpb_FieldType_SInt64; i++) {
290     ASSERT_TRUE(e.PutField(static_cast<upb_FieldType>(i), i, 0));
291     count++;
292   }
293   upb::Status status;
294   upb_MiniTable* table = _upb_MiniTable_Build(
295       e.data().data(), e.data().size(), GetParam(), arena.ptr(), status.ptr());
296   ASSERT_NE(nullptr, table);
297   EXPECT_EQ(kUpb_ExtMode_Extendable, table->ext & kUpb_ExtMode_Extendable);
298 }
299 
300 // begin:google_only
301 //
302 // static void BuildMiniTable(std::string_view s, bool is_32bit) {
303 //   upb::Arena arena;
304 //   upb::Status status;
305 //   _upb_MiniTable_Build(
306 //       s.data(), s.size(),
307 //       is_32bit ? kUpb_MiniTablePlatform_32Bit : kUpb_MiniTablePlatform_64Bit,
308 //       arena.ptr(), status.ptr());
309 // }
310 // FUZZ_TEST(FuzzTest, BuildMiniTable);
311 //
312 // TEST(FuzzTest, BuildMiniTableRegression) {
313 //   BuildMiniTable("g}{v~fq{\271", false);
314 // }
315 //
316 // end:google_only
317