1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2023 Google LLC. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 #include "upb/message/internal/compare_unknown.h"
9
10 #include <stdint.h>
11
12 #include <initializer_list>
13 #include <string>
14 #include <vector>
15
16 #include <gtest/gtest.h>
17 #include "absl/types/variant.h"
18 #include "upb/base/internal/endian.h"
19 #include "upb/wire/types.h"
20
21 // Must be last.
22 #include "upb/port/def.inc"
23
24 struct UnknownField;
25
26 using UnknownFields = std::vector<UnknownField>;
27
28 struct Varint {
VarintVarint29 explicit Varint(uint64_t _val) : val(_val) {}
30 uint64_t val;
31 };
32 struct LongVarint {
LongVarintLongVarint33 explicit LongVarint(uint64_t _val) : val(_val) {}
34 uint64_t val; // Over-encoded.
35 };
36 struct Delimited {
DelimitedDelimited37 explicit Delimited(std::string _val) : val(_val) {}
38 std::string val;
39 };
40 struct Fixed64 {
Fixed64Fixed6441 explicit Fixed64(uint64_t _val) : val(_val) {}
42 uint64_t val;
43 };
44 struct Fixed32 {
Fixed32Fixed3245 explicit Fixed32(uint32_t _val) : val(_val) {}
46 uint32_t val;
47 };
48 struct Group {
49 Group(std::initializer_list<UnknownField> _val);
50 UnknownFields val;
51 };
52
53 struct UnknownField {
54 uint32_t field_number;
55 absl::variant<Varint, LongVarint, Delimited, Fixed64, Fixed32, Group> value;
56 };
57
Group(std::initializer_list<UnknownField> _val)58 Group::Group(std::initializer_list<UnknownField> _val) : val(_val) {}
59
EncodeVarint(uint64_t val,std::string * str)60 void EncodeVarint(uint64_t val, std::string* str) {
61 do {
62 char byte = val & 0x7fU;
63 val >>= 7;
64 if (val) byte |= 0x80U;
65 str->push_back(byte);
66 } while (val);
67 }
68
ToBinaryPayload(const UnknownFields & fields)69 std::string ToBinaryPayload(const UnknownFields& fields) {
70 std::string ret;
71
72 for (const auto& field : fields) {
73 if (const auto* val = absl::get_if<Varint>(&field.value)) {
74 EncodeVarint(field.field_number << 3 | kUpb_WireType_Varint, &ret);
75 EncodeVarint(val->val, &ret);
76 } else if (const auto* val = absl::get_if<LongVarint>(&field.value)) {
77 EncodeVarint(field.field_number << 3 | kUpb_WireType_Varint, &ret);
78 EncodeVarint(val->val, &ret);
79 ret.back() |= 0x80;
80 ret.push_back(0);
81 } else if (const auto* val = absl::get_if<Delimited>(&field.value)) {
82 EncodeVarint(field.field_number << 3 | kUpb_WireType_Delimited, &ret);
83 EncodeVarint(val->val.size(), &ret);
84 ret.append(val->val);
85 } else if (const auto* val = absl::get_if<Fixed64>(&field.value)) {
86 EncodeVarint(field.field_number << 3 | kUpb_WireType_64Bit, &ret);
87 uint64_t swapped = upb_BigEndian64(val->val);
88 ret.append(reinterpret_cast<const char*>(&swapped), sizeof(swapped));
89 } else if (const auto* val = absl::get_if<Fixed32>(&field.value)) {
90 EncodeVarint(field.field_number << 3 | kUpb_WireType_32Bit, &ret);
91 uint32_t swapped = upb_BigEndian32(val->val);
92 ret.append(reinterpret_cast<const char*>(&swapped), sizeof(swapped));
93 } else if (const auto* val = absl::get_if<Group>(&field.value)) {
94 EncodeVarint(field.field_number << 3 | kUpb_WireType_StartGroup, &ret);
95 ret.append(ToBinaryPayload(val->val));
96 EncodeVarint(field.field_number << 3 | kUpb_WireType_EndGroup, &ret);
97 }
98 }
99
100 return ret;
101 }
102
CompareUnknownWithMaxDepth(UnknownFields uf1,UnknownFields uf2,int max_depth)103 upb_UnknownCompareResult CompareUnknownWithMaxDepth(UnknownFields uf1,
104 UnknownFields uf2,
105 int max_depth) {
106 std::string buf1 = ToBinaryPayload(uf1);
107 std::string buf2 = ToBinaryPayload(uf2);
108 return UPB_PRIVATE(_upb_Message_UnknownFieldsAreEqual)(
109 buf1.data(), buf1.size(), buf2.data(), buf2.size(), max_depth);
110 }
111
CompareUnknown(UnknownFields uf1,UnknownFields uf2)112 upb_UnknownCompareResult CompareUnknown(UnknownFields uf1, UnknownFields uf2) {
113 return CompareUnknownWithMaxDepth(uf1, uf2, 64);
114 }
115
TEST(CompareTest,UnknownFieldsReflexive)116 TEST(CompareTest, UnknownFieldsReflexive) {
117 EXPECT_EQ(kUpb_UnknownCompareResult_Equal, CompareUnknown({}, {}));
118 EXPECT_EQ(kUpb_UnknownCompareResult_Equal,
119 CompareUnknown({{1, Varint(123)}, {2, Fixed32(456)}},
120 {{1, Varint(123)}, {2, Fixed32(456)}}));
121 EXPECT_EQ(
122 kUpb_UnknownCompareResult_Equal,
123 CompareUnknown(
124 {{1, Group({{2, Group({{3, Fixed32(456)}, {4, Fixed64(123)}})}})}},
125 {{1, Group({{2, Group({{3, Fixed32(456)}, {4, Fixed64(123)}})}})}}));
126 }
127
TEST(CompareTest,UnknownFieldsOrdering)128 TEST(CompareTest, UnknownFieldsOrdering) {
129 EXPECT_EQ(kUpb_UnknownCompareResult_Equal,
130 CompareUnknown({{1, Varint(111)},
131 {2, Delimited("ABC")},
132 {3, Fixed32(456)},
133 {4, Fixed64(123)},
134 {5, Group({})}},
135 {{5, Group({})},
136 {4, Fixed64(123)},
137 {3, Fixed32(456)},
138 {2, Delimited("ABC")},
139 {1, Varint(111)}}));
140 EXPECT_EQ(kUpb_UnknownCompareResult_NotEqual,
141 CompareUnknown({{1, Varint(111)},
142 {2, Delimited("ABC")},
143 {3, Fixed32(456)},
144 {4, Fixed64(123)},
145 {5, Group({})}},
146 {{5, Group({})},
147 {4, Fixed64(123)},
148 {3, Fixed32(455)}, // Small difference.
149 {2, Delimited("ABC")},
150 {1, Varint(111)}}));
151 EXPECT_EQ(kUpb_UnknownCompareResult_Equal,
152 CompareUnknown({{3, Fixed32(456)}, {4, Fixed64(123)}},
153 {{4, Fixed64(123)}, {3, Fixed32(456)}}));
154 EXPECT_EQ(
155 kUpb_UnknownCompareResult_Equal,
156 CompareUnknown(
157 {{1, Group({{2, Group({{3, Fixed32(456)}, {4, Fixed64(123)}})}})}},
158 {{1, Group({{2, Group({{4, Fixed64(123)}, {3, Fixed32(456)}})}})}}));
159 }
160
TEST(CompareTest,LongVarint)161 TEST(CompareTest, LongVarint) {
162 EXPECT_EQ(kUpb_UnknownCompareResult_Equal,
163 CompareUnknown({{1, LongVarint(123)}, {2, LongVarint(456)}},
164 {{1, Varint(123)}, {2, Varint(456)}}));
165 EXPECT_EQ(kUpb_UnknownCompareResult_Equal,
166 CompareUnknown({{2, LongVarint(456)}, {1, LongVarint(123)}},
167 {{1, Varint(123)}, {2, Varint(456)}}));
168 }
169
TEST(CompareTest,MaxDepth)170 TEST(CompareTest, MaxDepth) {
171 EXPECT_EQ(
172 kUpb_UnknownCompareResult_MaxDepthExceeded,
173 CompareUnknownWithMaxDepth(
174 {{1, Group({{2, Group({{3, Fixed32(456)}, {4, Fixed64(123)}})}})}},
175 {{1, Group({{2, Group({{4, Fixed64(123)}, {3, Fixed32(456)}})}})}},
176 2));
177 }
178