library/cpp/packers/ut/proto_packer_ut.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#include "proto_packer.h"

#include <library/cpp/packers/ut/test.pb.h>
#include <library/cpp/testing/unittest/registar.h>

#include <util/generic/string.h>

using namespace NPackers;
using namespace NProtoPackerTest;

void FillRequiredFields(TTestMessage& msg) {
    msg.SetRequiredString("required_string");
    msg.SetRequiredInt32(42);
}

void FillOptionalFields(TTestMessage& msg) {
    msg.SetOptionalString("optional_string");
    msg.SetOptionalInt32(43);
}

void FillRepeatedFields(TTestMessage& msg) {
    msg.ClearRepeatedStrings();
    for (ui32 idx = 0; idx < 5; ++idx) {
        msg.AddRepeatedStrings("repeated_string" + ToString(idx));
    }
}

// do not want to use google/protobuf/util/message_differencer because of warnings
bool operator==(const TTestMessage& lhs, const TTestMessage& rhs) {
    if (lhs.GetRequiredString() != rhs.GetRequiredString() ||
        lhs.GetRequiredInt32() != rhs.GetRequiredInt32() ||
        lhs.HasOptionalString() != rhs.HasOptionalString() ||
        (lhs.HasOptionalString() && lhs.GetOptionalString() != rhs.GetOptionalString()) ||
        lhs.HasOptionalInt32() != rhs.HasOptionalInt32() ||
        (lhs.HasOptionalInt32() && lhs.GetOptionalInt32() != rhs.GetOptionalInt32()) ||
        lhs.RepeatedStringsSize() != rhs.RepeatedStringsSize())
    {
        return false;
    }
    for (ui32 idx = 0; idx < lhs.RepeatedStringsSize(); ++idx) {
        if (lhs.GetRepeatedStrings(idx) != rhs.GetRepeatedStrings(idx)) {
            return false;
        }
    }
    return true;
}

Y_UNIT_TEST_SUITE(ProtoPackerTestSuite) {
    TProtoMessagePacker<TTestMessage> Packer;
    TString Buffer;

    void DoPackUnpackTest(const TTestMessage& msg) {
        const ui32 msgByteSize = Packer.MeasureLeaf(msg);
        Buffer.resize(msgByteSize);

        Packer.PackLeaf(Buffer.begin(), msg, msgByteSize);

        TTestMessage checkMsg;
        Packer.UnpackLeaf(Buffer.begin(), checkMsg);

        UNIT_ASSERT_EQUAL(msg, checkMsg);
    }

    Y_UNIT_TEST(TestPackUnpackOnlyRequired) {
        TTestMessage msg;
        FillRequiredFields(msg);
        DoPackUnpackTest(msg);
    }

    Y_UNIT_TEST(TestPackUnpackRequiredAndOptional) {
        TTestMessage msg;
        FillRequiredFields(msg);
        FillOptionalFields(msg);
        DoPackUnpackTest(msg);
    }

    Y_UNIT_TEST(TestPackUnpackAll) {
        TTestMessage msg;
        FillRequiredFields(msg);
        FillOptionalFields(msg);
        FillRepeatedFields(msg);
        DoPackUnpackTest(msg);
    }

    Y_UNIT_TEST(TestSkipLeaf) {
        TTestMessage msgFirst;
        FillRequiredFields(msgFirst);
        TTestMessage msgSecond;
        FillRequiredFields(msgSecond);
        FillOptionalFields(msgSecond);

        const ui32 msgFirstByteSize = Packer.MeasureLeaf(msgFirst);
        const ui32 msgSecondByteSize = Packer.MeasureLeaf(msgSecond);

        Buffer.resize(msgFirstByteSize + msgSecondByteSize);
        Packer.PackLeaf(Buffer.begin(), msgFirst, msgFirstByteSize);
        Packer.PackLeaf(Buffer.begin() + msgFirstByteSize, msgSecond, msgSecondByteSize);

        TTestMessage checkMsg;
        Packer.UnpackLeaf(Buffer.begin() + Packer.SkipLeaf(Buffer.begin()), checkMsg);

        UNIT_ASSERT_EQUAL(msgSecond, checkMsg);
    }
}