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