userver: /data/code/userver/libraries/protobuf/tests/json/utils.cpp Source File
Loading...
Searching...
No Matches
utils.cpp
1#include "utils.hpp"
2
3#include <algorithm>
4#include <cmath>
5#include <stdexcept>
6
7#include <fmt/format.h>
8#include <google/protobuf/util/json_util.h>
9
10#include <userver/formats/json/serialize.hpp>
11#include <userver/utils/meta.hpp>
12
13USERVER_NAMESPACE_BEGIN
14
15namespace protobuf::json::tests {
16
17template <typename T>
18using SupportsCheckMessageEqual = decltype(CheckMessageEqual(std::declval<const T&>(), std::declval<const T&>()));
19
20template <typename T>
21inline constexpr bool kSupportsCheckMessageEqual = meta::IsDetected<SupportsCheckMessageEqual, T>;
22
23template <typename T>
24void AreProtobufRepeatedEqual(const T& lhs, const T& rhs) {
25 ASSERT_EQ(lhs.size(), rhs.size());
26
27 for (int i = 0; i < lhs.size(); ++i) {
28 if constexpr (kSupportsCheckMessageEqual<typename T::value_type>) {
29 CheckMessageEqual(lhs[i], rhs[i]);
30 } else {
31 EXPECT_EQ(lhs[i], rhs[i]);
32 }
33 }
34}
35
36template <typename T>
37void AreProtobufMapsEqual(const T& lhs, const T& rhs) {
38 EXPECT_EQ(lhs.size(), rhs.size());
39
40 for (const auto& [key, val] : lhs) {
41 ASSERT_TRUE(rhs.contains(key));
42
43 if constexpr (kSupportsCheckMessageEqual<typename T::mapped_type>) {
44 CheckMessageEqual(val, rhs.at(key));
45 } else {
46 EXPECT_EQ(val, rhs.at(key));
47 }
48 }
49}
50
51formats::json::Value PrepareJsonTestData(const std::string& json_data) { return formats::json::FromString(json_data); }
52
53formats::json::Value CreateSampleJson(const ::google::protobuf::Message& message, const PrintOptions& options) {
54 using StringType = std::decay_t<decltype(message.DebugString())>;
55
56 StringType result;
57 ::google::protobuf::util::JsonPrintOptions native_options;
58#if GOOGLE_PROTOBUF_VERSION >= 5026001
59 native_options.always_print_fields_with_no_presence = options.always_print_fields_with_no_presence;
60#else
61 native_options.always_print_primitive_fields = options.always_print_fields_with_no_presence;
62#endif
63 native_options.always_print_enums_as_ints = options.always_print_enums_as_ints;
64 native_options.preserve_proto_field_names = options.preserve_proto_field_names;
65
66 auto status = ::google::protobuf::util::MessageToJsonString(message, &result, native_options);
67
68 if (status.ok()) {
69 return formats::json::FromString(result);
70 } else {
71 throw SampleError(fmt::format("Failed to create sample JSON from protobuf message: {}", status.message()));
72 }
73}
74
75void InitSampleMessage(const std::string& json, ::google::protobuf::Message& message, const ParseOptions& options) {
76 ::google::protobuf::util::ParseOptions native_options;
77 native_options.ignore_unknown_fields = options.ignore_unknown_fields;
78
79 auto status = ::google::protobuf::util::JsonStringToMessage(json, &message, native_options);
80
81 if (!status.ok()) {
82 throw SampleError(fmt::format("Failed to initialize sample message from JSON: {}", status.message()));
83 }
84}
85
86::google::protobuf::Value ProtoValueToNative(const ProtoValue& data) {
87 struct Visitor {
88 ::google::protobuf::Value result;
89
90 ::google::protobuf::Value operator()(std::monostate) const { return result; }
91
92 ::google::protobuf::Value operator()(ProtoNullValue) {
93 result.set_null_value(::google::protobuf::NULL_VALUE);
94 return result;
95 }
96
97 ::google::protobuf::Value operator()(double val) {
98 result.set_number_value(val);
99 return result;
100 }
101
102 ::google::protobuf::Value operator()(const std::string& val) {
103 result.set_string_value(val);
104 return result;
105 }
106
107 ::google::protobuf::Value operator()(bool val) {
108 result.set_bool_value(val);
109 return result;
110 }
111
112 ::google::protobuf::Value operator()(const std::vector<double>& val) {
113 auto& arr = *result.mutable_list_value();
114
115 for (const auto& item : val) {
116 arr.add_values()->set_number_value(item);
117 }
118
119 return result;
120 }
121
122 ::google::protobuf::Value operator()(const std::map<std::string, std::string>& val) {
123 auto& fields = *result.mutable_struct_value()->mutable_fields();
124
125 for (const auto& [key, value] : val) {
126 fields[key].set_string_value(value);
127 }
128
129 return result;
130 }
131 };
132
133 return std::visit(Visitor{}, data);
134}
135
136proto_json::messages::Int32Message PrepareTestData(const Int32MessageData& message_data) {
137 proto_json::messages::Int32Message message;
138 message.set_field1(message_data.field1);
139 message.set_field2(message_data.field2);
140 message.set_field3(message_data.field3);
141 return message;
142}
143
144void CheckMessageEqual(const proto_json::messages::Int32Message& lhs, const proto_json::messages::Int32Message& rhs) {
145 EXPECT_EQ(lhs.field1(), rhs.field1());
146 EXPECT_EQ(lhs.field2(), rhs.field2());
147 EXPECT_EQ(lhs.field3(), rhs.field3());
148}
149
150proto_json::messages::UInt32Message PrepareTestData(const UInt32MessageData& message_data) {
151 proto_json::messages::UInt32Message message;
152 message.set_field1(message_data.field1);
153 message.set_field2(message_data.field2);
154 return message;
155}
156
157void CheckMessageEqual(const proto_json::messages::UInt32Message& lhs, const proto_json::messages::UInt32Message& rhs) {
158 EXPECT_EQ(lhs.field1(), rhs.field1());
159 EXPECT_EQ(lhs.field2(), rhs.field2());
160}
161
162proto_json::messages::Int64Message PrepareTestData(const Int64MessageData& message_data) {
163 proto_json::messages::Int64Message message;
164 message.set_field1(message_data.field1);
165 message.set_field2(message_data.field2);
166 message.set_field3(message_data.field3);
167 return message;
168}
169
170void CheckMessageEqual(const proto_json::messages::Int64Message& lhs, const proto_json::messages::Int64Message& rhs) {
171 EXPECT_EQ(lhs.field1(), rhs.field1());
172 EXPECT_EQ(lhs.field2(), rhs.field2());
173 EXPECT_EQ(lhs.field3(), rhs.field3());
174}
175
176proto_json::messages::UInt64Message PrepareTestData(const UInt64MessageData& message_data) {
177 proto_json::messages::UInt64Message message;
178 message.set_field1(message_data.field1);
179 message.set_field2(message_data.field2);
180 return message;
181}
182
183void CheckMessageEqual(const proto_json::messages::UInt64Message& lhs, const proto_json::messages::UInt64Message& rhs) {
184 EXPECT_EQ(lhs.field1(), rhs.field1());
185 EXPECT_EQ(lhs.field2(), rhs.field2());
186}
187
188proto_json::messages::FloatMessage PrepareTestData(const FloatMessageData& message_data) {
189 proto_json::messages::FloatMessage message;
190 message.set_field1(message_data.field1);
191 return message;
192}
193
194void CheckMessageEqual(const proto_json::messages::FloatMessage& lhs, const proto_json::messages::FloatMessage& rhs) {
195 if (!std::isnan(lhs.field1())) {
196 EXPECT_EQ(lhs.field1(), rhs.field1());
197 } else {
198 EXPECT_TRUE(std::isnan(rhs.field1()));
199 }
200}
201
202proto_json::messages::DoubleMessage PrepareTestData(const DoubleMessageData& message_data) {
203 proto_json::messages::DoubleMessage message;
204 message.set_field1(message_data.field1);
205 return message;
206}
207
208void CheckMessageEqual(const proto_json::messages::DoubleMessage& lhs, const proto_json::messages::DoubleMessage& rhs) {
209 if (!std::isnan(lhs.field1())) {
210 EXPECT_EQ(lhs.field1(), rhs.field1());
211 } else {
212 EXPECT_TRUE(std::isnan(rhs.field1()));
213 }
214}
215
216proto_json::messages::BoolMessage PrepareTestData(const BoolMessageData& message_data) {
217 proto_json::messages::BoolMessage message;
218 message.set_field1(message_data.field1);
219 return message;
220}
221
222void CheckMessageEqual(const proto_json::messages::BoolMessage& lhs, const proto_json::messages::BoolMessage& rhs) {
223 EXPECT_EQ(lhs.field1(), rhs.field1());
224}
225
226proto_json::messages::StringMessage PrepareTestData(const StringMessageData& message_data) {
227 proto_json::messages::StringMessage message;
228 message.set_field1(message_data.field1);
229 return message;
230}
231
232void CheckMessageEqual(const proto_json::messages::StringMessage& lhs, const proto_json::messages::StringMessage& rhs) {
233 EXPECT_EQ(lhs.field1(), rhs.field1());
234}
235
236proto_json::messages::BytesMessage PrepareTestData(const BytesMessageData& message_data) {
237 proto_json::messages::BytesMessage message;
238 message.set_field1(message_data.field1);
239 return message;
240}
241
242void CheckMessageEqual(const proto_json::messages::BytesMessage& lhs, const proto_json::messages::BytesMessage& rhs) {
243 EXPECT_EQ(lhs.field1(), rhs.field1());
244}
245
246proto_json::messages::EnumMessage PrepareTestData(const EnumMessageData& message_data) {
247 proto_json::messages::EnumMessage message;
248 message.set_field1(message_data.field1);
249
250 if (message_data.field2) {
251 message.set_field2(message_data.field2.value());
252 }
253
254 return message;
255}
256
257void CheckMessageEqual(const proto_json::messages::EnumMessage& lhs, const proto_json::messages::EnumMessage& rhs) {
258 EXPECT_EQ(lhs.field1(), rhs.field1());
259 EXPECT_EQ(lhs.has_field2(), rhs.has_field2());
260 EXPECT_EQ(lhs.field2(), rhs.field2());
261}
262
263proto_json::messages::NestedMessage PrepareTestData(const NestedMessageData& message_data) {
264 proto_json::messages::NestedMessage message;
265 if (message_data.field1) {
266 message.mutable_parent()->set_field1(message_data.field1.value());
267 }
268 return message;
269}
270
271void CheckMessageEqual(const proto_json::messages::NestedMessage& lhs, const proto_json::messages::NestedMessage& rhs) {
272 EXPECT_EQ(lhs.has_parent(), rhs.has_parent());
273 EXPECT_EQ(lhs.parent().field1(), rhs.parent().field1());
274}
275
276proto_json::messages::WrapperMessage PrepareTestData(const WrapperMessageData& message_data) {
277 proto_json::messages::WrapperMessage message;
278
279 if (message_data.field1) {
280 message.mutable_field1()->set_value(message_data.field1.value());
281 }
282
283 if (message_data.field2) {
284 message.mutable_field2()->set_value(message_data.field2.value());
285 }
286
287 if (message_data.field3) {
288 message.mutable_field3()->set_value(message_data.field3.value());
289 }
290
291 if (message_data.field4) {
292 message.mutable_field4()->set_value(message_data.field4.value());
293 }
294
295 if (message_data.field5) {
296 message.mutable_field5()->set_value(message_data.field5.value());
297 }
298
299 if (message_data.field6) {
300 message.mutable_field6()->set_value(message_data.field6.value());
301 }
302
303 if (message_data.field7) {
304 message.mutable_field7()->set_value(message_data.field7.value());
305 }
306
307 if (message_data.field8) {
308 message.mutable_field8()->set_value(message_data.field8.value());
309 }
310
311 if (message_data.field9) {
312 message.mutable_field9()->set_value(message_data.field9.value());
313 }
314 return message;
315}
316
317void CheckMessageEqual(
318 const proto_json::messages::WrapperMessage& lhs,
319 const proto_json::messages::WrapperMessage& rhs
320) {
321 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
322 EXPECT_EQ(lhs.has_field2(), rhs.has_field2());
323 EXPECT_EQ(lhs.has_field3(), rhs.has_field3());
324 EXPECT_EQ(lhs.has_field4(), rhs.has_field4());
325 EXPECT_EQ(lhs.has_field5(), rhs.has_field5());
326 EXPECT_EQ(lhs.has_field6(), rhs.has_field6());
327 EXPECT_EQ(lhs.has_field7(), rhs.has_field7());
328 EXPECT_EQ(lhs.has_field8(), rhs.has_field8());
329 EXPECT_EQ(lhs.has_field9(), rhs.has_field9());
330
331 EXPECT_EQ(lhs.field1().value(), rhs.field1().value());
332 EXPECT_EQ(lhs.field2().value(), rhs.field2().value());
333 EXPECT_EQ(lhs.field3().value(), rhs.field3().value());
334 EXPECT_EQ(lhs.field4().value(), rhs.field4().value());
335 EXPECT_EQ(lhs.field5().value(), rhs.field5().value());
336 EXPECT_EQ(lhs.field6().value(), rhs.field6().value());
337 EXPECT_EQ(lhs.field7().value(), rhs.field7().value());
338 EXPECT_EQ(lhs.field8().value(), rhs.field8().value());
339 EXPECT_EQ(lhs.field9().value(), rhs.field9().value());
340}
341
342proto_json::messages::FieldMaskMessage PrepareTestData(const FieldMaskMessageData& message_data) {
343 proto_json::messages::FieldMaskMessage message;
344
345 if (!message_data.field1) {
346 return message;
347 }
348
349 (void)message.mutable_field1();
350
351 for (const auto& path : message_data.field1.value()) {
352 message.mutable_field1()->add_paths(path);
353 }
354
355 return message;
356}
357
358void CheckMessageEqual(const ::google::protobuf::FieldMask& lhs, const ::google::protobuf::FieldMask& rhs) {
359 std::vector<std::string> mask_lhs;
360 std::vector<std::string> mask_rhs;
361
362 for (const auto& path : lhs.paths()) {
363 mask_lhs.push_back(path);
364 }
365
366 for (const auto& path : rhs.paths()) {
367 mask_rhs.push_back(path);
368 }
369
370 std::sort(mask_lhs.begin(), mask_lhs.end());
371 std::sort(mask_rhs.begin(), mask_rhs.end());
372
373 EXPECT_EQ(mask_lhs, mask_rhs);
374}
375
376void CheckMessageEqual(
377 const proto_json::messages::FieldMaskMessage& lhs,
378 const proto_json::messages::FieldMaskMessage& rhs
379) {
380 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
381 CheckMessageEqual(lhs.field1(), rhs.field1());
382}
383
384proto_json::messages::DurationMessage PrepareTestData(const DurationMessageData& message_data) {
385 proto_json::messages::DurationMessage message;
386
387 if (!message_data.do_not_set) {
388 message.mutable_field1()->set_seconds(message_data.seconds);
389 message.mutable_field1()->set_nanos(message_data.nanos);
390 }
391
392 return message;
393}
394
395void CheckMessageEqual(const ::google::protobuf::Duration& lhs, const ::google::protobuf::Duration& rhs) {
396 EXPECT_EQ(lhs.seconds(), rhs.seconds());
397 EXPECT_EQ(lhs.nanos(), rhs.nanos());
398}
399
400void CheckMessageEqual(
401 const proto_json::messages::DurationMessage& lhs,
402 const proto_json::messages::DurationMessage& rhs
403) {
404 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
405 CheckMessageEqual(lhs.field1(), rhs.field1());
406}
407
408proto_json::messages::TimestampMessage PrepareTestData(const TimestampMessageData& message_data) {
409 proto_json::messages::TimestampMessage message;
410
411 if (!message_data.do_not_set) {
412 message.mutable_field1()->set_seconds(message_data.seconds);
413 message.mutable_field1()->set_nanos(message_data.nanos);
414 }
415
416 return message;
417}
418
419void CheckMessageEqual(const ::google::protobuf::Timestamp& lhs, const ::google::protobuf::Timestamp& rhs) {
420 EXPECT_EQ(lhs.seconds(), rhs.seconds());
421 EXPECT_EQ(lhs.nanos(), rhs.nanos());
422}
423
424void CheckMessageEqual(
425 const proto_json::messages::TimestampMessage& lhs,
426 const proto_json::messages::TimestampMessage& rhs
427) {
428 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
429 CheckMessageEqual(lhs.field1(), rhs.field1());
430}
431
432proto_json::messages::ValueMessage PrepareTestData(const ValueMessageData& message_data) {
433 struct Visitor {
434 proto_json::messages::ValueMessage result;
435
436 proto_json::messages::ValueMessage operator()(const ProtoValue& val) {
437 *result.mutable_field1() = ProtoValueToNative(val);
438 return result;
439 }
440
441 proto_json::messages::ValueMessage operator()(const std::vector<ProtoValue>& val) {
442 auto& arr = *result.mutable_field1()->mutable_list_value();
443
444 for (const auto& item : val) {
445 *arr.add_values() = ProtoValueToNative(item);
446 }
447
448 return result;
449 }
450
451 proto_json::messages::ValueMessage operator()(const std::map<std::string, ProtoValue>& val) {
452 auto& fields = *result.mutable_field1()->mutable_struct_value()->mutable_fields();
453
454 for (const auto& [key, value] : val) {
455 fields[key] = ProtoValueToNative(value);
456 }
457
458 return result;
459 }
460 };
461
462 if (message_data.field1) {
463 return std::visit(Visitor{}, *message_data.field1);
464 } else {
465 return proto_json::messages::ValueMessage{};
466 }
467}
468
469void CheckMessageEqual(const ::google::protobuf::Value& lhs, const ::google::protobuf::Value& rhs) {
470 if (lhs.has_null_value()) {
471 ASSERT_TRUE(rhs.has_null_value());
472 EXPECT_EQ(lhs.null_value(), rhs.null_value());
473 } else if (lhs.has_number_value()) {
474 ASSERT_TRUE(rhs.has_number_value());
475 EXPECT_EQ(lhs.number_value(), rhs.number_value());
476 } else if (lhs.has_string_value()) {
477 ASSERT_TRUE(rhs.has_string_value());
478 EXPECT_EQ(lhs.string_value(), rhs.string_value());
479 } else if (lhs.has_bool_value()) {
480 ASSERT_TRUE(rhs.has_bool_value());
481 EXPECT_EQ(lhs.bool_value(), rhs.bool_value());
482 } else if (lhs.has_list_value()) {
483 ASSERT_TRUE(rhs.has_list_value());
484 CheckMessageEqual(lhs.list_value(), rhs.list_value());
485 } else if (lhs.has_struct_value()) {
486 ASSERT_TRUE(rhs.has_struct_value());
487 CheckMessageEqual(lhs.struct_value(), rhs.struct_value());
488 } else {
489 EXPECT_TRUE(
490 !rhs.has_null_value() && !rhs.has_number_value() && !rhs.has_string_value() && !rhs.has_bool_value() &&
491 !rhs.has_list_value() && !rhs.has_struct_value()
492 );
493 }
494}
495
496void CheckMessageEqual(const ::google::protobuf::ListValue& lhs, const ::google::protobuf::ListValue& rhs) {
497 AreProtobufRepeatedEqual(lhs.values(), rhs.values());
498}
499
500void CheckMessageEqual(const ::google::protobuf::Struct& lhs, const ::google::protobuf::Struct& rhs) {
501 AreProtobufMapsEqual(lhs.fields(), rhs.fields());
502}
503
504void CheckMessageEqual(const proto_json::messages::ValueMessage& lhs, const proto_json::messages::ValueMessage& rhs) {
505 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
506 CheckMessageEqual(lhs.field1(), rhs.field1());
507}
508
509template <typename T>
510void CheckAnyPayloadEqual(const ::google::protobuf::Any& lhs, const ::google::protobuf::Any& rhs) {
511 ASSERT_TRUE(lhs.Is<T>());
512 ASSERT_TRUE(rhs.Is<T>());
513
514 T lhs_payload;
515 T rhs_payload;
516
517 ASSERT_TRUE(lhs.UnpackTo(&lhs_payload));
518 ASSERT_TRUE(rhs.UnpackTo(&rhs_payload));
519
520 CheckMessageEqual(lhs_payload, rhs_payload);
521}
522
523proto_json::messages::AnyMessage PrepareTestData(const AnyMessageData& message_data) {
524 struct Visitor {
525 ::google::protobuf::Any result;
526
527 ::google::protobuf::Any operator()(const Int32MessageData& payload) {
528 auto msg = PrepareTestData(payload);
529
530 if (!result.PackFrom(msg)) {
531 throw std::runtime_error("Failed to create 'google.protobuf.Any'");
532 }
533
534 return result;
535 }
536
537 ::google::protobuf::Any operator()(const DurationMessageData& payload) {
538 const auto msg = PrepareTestData(payload);
539
540 if (!result.PackFrom(msg.field1())) {
541 throw std::runtime_error("Failed to create 'google.protobuf.Any'");
542 }
543
544 return result;
545 }
546
547 ::google::protobuf::Any operator()(const ValueMessageData& payload) {
548 const auto msg = PrepareTestData(payload);
549
550 if (!result.PackFrom(msg.field1())) {
551 throw std::runtime_error("Failed to create 'google.protobuf.Any'");
552 }
553
554 return result;
555 }
556
557 ::google::protobuf::Any operator()(const RawAnyData& payload) {
558 result.set_type_url(payload.type_url);
559 result.set_value(payload.value);
560 return result;
561 }
562 };
563
564 proto_json::messages::AnyMessage result;
565
566 if (!message_data.field1) {
567 return result;
568 }
569
570 auto any_message = std::visit(Visitor{}, message_data.field1.value());
571
572 if (!message_data.add_nesting) {
573 *result.mutable_field1() = std::move(any_message);
574 } else {
575 ::google::protobuf::Any top;
576
577 if (!top.PackFrom(any_message)) {
578 throw std::runtime_error("Failed to create top-level 'google.protobuf.Any'");
579 }
580
581 *result.mutable_field1() = std::move(top);
582 }
583
584 return result;
585}
586
587void CheckMessageEqual(const ::google::protobuf::Any& lhs, const ::google::protobuf::Any& rhs) {
588 if (lhs.Is<proto_json::messages::Int32Message>()) {
589 CheckAnyPayloadEqual<proto_json::messages::Int32Message>(lhs, rhs);
590 } else if (lhs.Is<::google::protobuf::Duration>()) {
591 CheckAnyPayloadEqual<::google::protobuf::Duration>(lhs, rhs);
592 } else if (lhs.Is<::google::protobuf::Value>()) {
593 CheckAnyPayloadEqual<::google::protobuf::Value>(lhs, rhs);
594 } else if (lhs.Is<::google::protobuf::Any>()) {
595 CheckAnyPayloadEqual<::google::protobuf::Any>(lhs, rhs);
596 } else {
597 EXPECT_EQ(lhs.type_url(), rhs.type_url());
598 EXPECT_EQ(lhs.value(), rhs.value());
599 }
600}
601
602void CheckMessageEqual(const proto_json::messages::AnyMessage& lhs, const proto_json::messages::AnyMessage& rhs) {
603 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
604
605 if (lhs.has_field1()) {
606 CheckMessageEqual(lhs.field1(), rhs.field1());
607 }
608}
609
610proto_json::messages::OneofMessage PrepareTestData(const OneofMessageData& message_data) {
611 proto_json::messages::OneofMessage result;
612
613 if (message_data.field1) {
614 result.set_field1(message_data.field1.value());
615 } else if (message_data.field2) {
616 result.set_field2(message_data.field2.value());
617 }
618
619 return result;
620}
621
622void CheckMessageEqual(const proto_json::messages::OneofMessage& lhs, const proto_json::messages::OneofMessage& rhs) {
623 if (lhs.has_field1()) {
624 EXPECT_TRUE(rhs.has_field1());
625 EXPECT_EQ(lhs.field1(), rhs.field1());
626 } else if (lhs.has_field2()) {
627 EXPECT_TRUE(rhs.has_field2());
628 EXPECT_EQ(lhs.field2(), rhs.field2());
629 } else {
630 EXPECT_FALSE(rhs.has_field1() || rhs.has_field2());
631 }
632}
633
634proto_json::messages::RepeatedMessage PrepareTestData(const RepeatedMessageData& message_data) {
635 proto_json::messages::RepeatedMessage result;
636
637 for (const auto& item : message_data.field1) {
638 result.add_field1(item);
639 }
640
641 for (const auto& item : message_data.field2) {
642 *result.add_field2() = PrepareTestData(item);
643 }
644
645 for (const auto& item : message_data.field3) {
646 *result.add_field3() = PrepareTestData(item).field1();
647 }
648
649 for (const auto& item : message_data.field4) {
650 *result.add_field4() = ProtoValueToNative(item);
651 }
652
653 for (const auto& item : message_data.field5) {
654 result.add_field5(item);
655 }
656
657 for (const auto& item : message_data.field6) {
658 result.add_field6(item);
659 }
660
661 for (const auto& item : message_data.field7) {
662 result.add_field7(item);
663 }
664
665 for (const auto& item : message_data.field8) {
666 result.add_field8(item);
667 }
668
669 for (const auto& item : message_data.field9) {
670 result.add_field9(item);
671 }
672
673 for (const auto& item : message_data.field10) {
674 result.add_field10(item);
675 }
676
677 for (const auto& item : message_data.field11) {
678 result.add_field11(item);
679 }
680
681 for (const auto& item : message_data.field12) {
682 result.add_field12(item);
683 }
684
685 return result;
686}
687
688void CheckMessageEqual(
689 const proto_json::messages::RepeatedMessage& lhs,
690 const proto_json::messages::RepeatedMessage& rhs
691) {
692 AreProtobufRepeatedEqual(lhs.field1(), rhs.field1());
693 AreProtobufRepeatedEqual(lhs.field2(), rhs.field2());
694 AreProtobufRepeatedEqual(lhs.field3(), rhs.field3());
695 AreProtobufRepeatedEqual(lhs.field4(), rhs.field4());
696 AreProtobufRepeatedEqual(lhs.field5(), rhs.field5());
697 AreProtobufRepeatedEqual(lhs.field6(), rhs.field6());
698 AreProtobufRepeatedEqual(lhs.field7(), rhs.field7());
699 AreProtobufRepeatedEqual(lhs.field8(), rhs.field8());
700 AreProtobufRepeatedEqual(lhs.field9(), rhs.field9());
701 AreProtobufRepeatedEqual(lhs.field10(), rhs.field10());
702 AreProtobufRepeatedEqual(lhs.field11(), rhs.field11());
703 AreProtobufRepeatedEqual(lhs.field12(), rhs.field12());
704}
705
706proto_json::messages::MapMessage PrepareTestData(const MapMessageData& message_data) {
707 proto_json::messages::MapMessage result;
708
709 for (const auto& [key, val] : message_data.field1) {
710 (*result.mutable_field1())[key] = val;
711 }
712
713 for (const auto& [key, val] : message_data.field2) {
714 (*result.mutable_field2())[key] = val;
715 }
716
717 for (const auto& [key, val] : message_data.field3) {
718 (*result.mutable_field3())[key] = val;
719 }
720
721 for (const auto& [key, val] : message_data.field4) {
722 (*result.mutable_field4())[key] = val;
723 }
724
725 for (const auto& [key, val] : message_data.field5) {
726 (*result.mutable_field5())[key] = val;
727 }
728
729 for (const auto& [key, val] : message_data.field6) {
730 (*result.mutable_field6())[key] = PrepareTestData(val);
731 }
732
733 for (const auto& [key, val] : message_data.field7) {
734 (*result.mutable_field7())[key] = PrepareTestData(val).field1();
735 }
736
737 for (const auto& [key, val] : message_data.field8) {
738 (*result.mutable_field8())[key] = ProtoValueToNative(val);
739 }
740
741 return result;
742}
743
744void CheckMessageEqual(const proto_json::messages::MapMessage& lhs, const proto_json::messages::MapMessage& rhs) {
745 AreProtobufMapsEqual(lhs.field1(), rhs.field1());
746 AreProtobufMapsEqual(lhs.field2(), rhs.field2());
747 AreProtobufMapsEqual(lhs.field3(), rhs.field3());
748 AreProtobufMapsEqual(lhs.field4(), rhs.field4());
749 AreProtobufMapsEqual(lhs.field5(), rhs.field5());
750 AreProtobufMapsEqual(lhs.field6(), rhs.field6());
751 AreProtobufMapsEqual(lhs.field7(), rhs.field7());
752 AreProtobufMapsEqual(lhs.field8(), rhs.field8());
753}
754
755proto_json::messages::NullValueMessage PrepareTestData(const NullValueMessageData& message_data) {
756 proto_json::messages::NullValueMessage result;
757 result.set_field1(message_data.field1);
758
759 if (message_data.field2) {
760 result.set_field2(message_data.field2.value());
761 }
762
763 for (const auto& item : message_data.field3) {
764 result.add_field3(item);
765 }
766
767 for (const auto& [key, val] : message_data.field4) {
768 (*result.mutable_field4())[key] = val;
769 }
770
771 return result;
772}
773
774void CheckMessageEqual(
775 const proto_json::messages::NullValueMessage& lhs,
776 const proto_json::messages::NullValueMessage& rhs
777) {
778 EXPECT_EQ(lhs.field1(), rhs.field1());
779
780 if (lhs.has_field2()) {
781 EXPECT_TRUE(rhs.has_field2());
782 EXPECT_EQ(lhs.field2(), rhs.field2());
783 } else {
784 EXPECT_FALSE(rhs.has_field2());
785 }
786
787 AreProtobufRepeatedEqual(lhs.field3(), rhs.field3());
788 AreProtobufMapsEqual(lhs.field4(), rhs.field4());
789}
790
791proto_json::messages::PresenceMessage PrepareTestData(const PresenceMessageData& message_data) {
792 proto_json::messages::PresenceMessage result;
793
794 result.set_field1(message_data.field1);
795
796 if (message_data.field2) {
797 result.set_field2(message_data.field2.value());
798 }
799
800 if (message_data.field3) {
801 result.mutable_field3()->set_field1(message_data.field3->field1);
802 result.mutable_field3()->set_field2(message_data.field3->field2);
803 result.mutable_field3()->set_field3(message_data.field3->field3);
804 }
805
806 if (!message_data.field4.empty()) {
807 for (const auto& val : message_data.field4) {
808 result.add_field4(val);
809 }
810 }
811
812 if (!message_data.field5.empty()) {
813 for (const auto& [key, val] : message_data.field5) {
814 (*result.mutable_field5())[key] = val;
815 }
816 }
817
818 return result;
819}
820
821void CheckMessageEqual(
822 const proto_json::messages::PresenceMessage& lhs,
823 const proto_json::messages::PresenceMessage& rhs
824) {
825 EXPECT_EQ(lhs.field1(), rhs.field1());
826
827 if (lhs.has_field2()) {
828 EXPECT_TRUE(rhs.has_field2());
829 EXPECT_EQ(lhs.field2(), rhs.field2());
830 } else {
831 EXPECT_FALSE(rhs.has_field2());
832 }
833
834 if (lhs.has_field3()) {
835 EXPECT_TRUE(rhs.has_field3());
836 CheckMessageEqual(lhs.field3(), rhs.field3());
837 } else {
838 EXPECT_FALSE(rhs.has_field3());
839 }
840
841 AreProtobufRepeatedEqual(lhs.field4(), rhs.field4());
842 AreProtobufMapsEqual(lhs.field5(), rhs.field5());
843}
844
845proto_json::messages::UnknownFieldMessage PrepareTestData(const UnknownFieldMessageData& message_data) {
846 proto_json::messages::UnknownFieldMessage result;
847
848 *result.mutable_field1() = PrepareTestData(message_data.field1);
849
850 for (const auto& item : message_data.field2) {
851 *result.add_field2() = PrepareTestData(item);
852 }
853
854 for (const auto& [key, val] : message_data.field3) {
855 (*result.mutable_field3())[key] = PrepareTestData(val);
856 }
857
858 return result;
859}
860
861void CheckMessageEqual(
862 const proto_json::messages::UnknownFieldMessage& lhs,
863 const proto_json::messages::UnknownFieldMessage& rhs
864) {
865 EXPECT_EQ(lhs.has_field1(), rhs.has_field1());
866 CheckMessageEqual(lhs.field1(), rhs.field1());
867
868 AreProtobufRepeatedEqual(lhs.field2(), rhs.field2());
869 AreProtobufMapsEqual(lhs.field3(), rhs.field3());
870}
871
872} // namespace protobuf::json::tests
873
874USERVER_NAMESPACE_END