DCCL v4
Loading...
Searching...
No Matches
test.cpp
1// Copyright 2011-2023:
2// GobySoft, LLC (2013-)
3// Massachusetts Institute of Technology (2007-2014)
4// Community contributors (see AUTHORS file)
5// File authors:
6// Toby Schneider <toby@gobysoft.org>
7//
8//
9// This file is part of the Dynamic Compact Control Language Library
10// ("DCCL").
11//
12// DCCL is free software: you can redistribute it and/or modify
13// it under the terms of the GNU Lesser General Public License as published by
14// the Free Software Foundation, either version 2.1 of the License, or
15// (at your option) any later version.
16//
17// DCCL is distributed in the hope that it will be useful,
18// but WITHOUT ANY WARRANTY; without even the implied warranty of
19// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20// GNU Lesser General Public License for more details.
21//
22// You should have received a copy of the GNU Lesser General Public License
23// along with DCCL. If not, see <http://www.gnu.org/licenses/>.
24// tests usage of Legacy CCL
25
26#include "../../codec.h"
27#include "../../native_protobuf/dccl_native_protobuf.h"
28#include "test.pb.h"
29
30using namespace dccl::test;
31
32
33// ensure we link in dccl_native_protobuf.so
34dccl::native_protobuf::EnumFieldCodec dummy;
35
36void fill_message(NativeProtobufTest& msg_in)
37{
38 int i = 0;
39 msg_in.set_double_default_optional(++i + 0.1);
40 msg_in.set_float_default_optional(++i + 0.2);
41
42 msg_in.set_int32_default_optional(++i);
43 msg_in.set_int64_default_optional(-++i);
44 msg_in.set_uint32_default_optional(++i);
45 msg_in.set_uint64_default_optional(++i);
46 msg_in.set_sint32_default_optional(-++i);
47 msg_in.set_sint64_default_optional(++i);
48 msg_in.set_fixed32_default_optional(++i);
49 msg_in.set_fixed64_default_optional(++i);
50 msg_in.set_sfixed32_default_optional(++i);
51 msg_in.set_sfixed64_default_optional(-++i);
52
53 msg_in.set_bool_default_optional(true);
54
55 msg_in.set_enum_default_optional(ENUM_C);
56
57 msg_in.set_double_default_required(++i + 0.1);
58 msg_in.set_float_default_required(++i + 0.2);
59
60 msg_in.set_int32_default_required(++i);
61 msg_in.set_int64_default_required(-++i);
62 msg_in.set_uint32_default_required(++i);
63 msg_in.set_uint64_default_required(++i);
64 msg_in.set_sint32_default_required(-++i);
65 msg_in.set_sint64_default_required(++i);
66 msg_in.set_fixed32_default_required(++i);
67 msg_in.set_fixed64_default_required(++i);
68 msg_in.set_sfixed32_default_required(++i);
69 msg_in.set_sfixed64_default_required(-++i);
70
71 msg_in.set_bool_default_required(true);
72
73 msg_in.set_enum_default_required(ENUM_C);
74
75 for (int j = 0; j < 4; ++j)
76 {
77 msg_in.add_double_default_repeat(++i + 0.1);
78 msg_in.add_int32_default_repeat(++i);
79 }
80}
81
82void fill_message_partial(NativeProtobufTest& msg_in)
83{
84 int i = 0;
85 msg_in.set_double_default_optional(++i + 0.1);
86 msg_in.set_float_default_optional(++i + 0.2);
87
88 msg_in.set_int32_default_optional(++i);
89 msg_in.set_uint32_default_optional(++i);
90 msg_in.set_uint64_default_optional(++i);
91 msg_in.set_sint64_default_optional(++i);
92 msg_in.set_fixed32_default_optional(++i);
93 msg_in.set_sfixed32_default_optional(++i);
94 msg_in.set_sfixed64_default_optional(-++i);
95
96 msg_in.set_double_default_required(++i + 0.1);
97 msg_in.set_float_default_required(++i + 0.2);
98
99 msg_in.set_int32_default_required(++i);
100 msg_in.set_int64_default_required(-++i);
101 msg_in.set_uint32_default_required(++i);
102 msg_in.set_uint64_default_required(++i);
103 msg_in.set_sint32_default_required(-++i);
104 msg_in.set_sint64_default_required(++i);
105 msg_in.set_fixed32_default_required(++i);
106 msg_in.set_fixed64_default_required(++i);
107 msg_in.set_sfixed32_default_required(++i);
108 msg_in.set_sfixed64_default_required(-++i);
109
110 msg_in.set_bool_default_required(true);
111
112 msg_in.set_enum_default_required(ENUM_C);
113
114 for (int j = 0; j < 2; ++j)
115 {
116 msg_in.add_double_default_repeat(++i + 0.1);
117 msg_in.add_int32_default_repeat(++i);
118 }
119}
120
121void fill_message_max(NativeProtobufTest& msg_in)
122{
123 msg_in.set_double_default_optional(std::numeric_limits<double>::max());
124 msg_in.set_float_default_optional(std::numeric_limits<float>::max());
125
126 msg_in.set_int32_default_optional(std::numeric_limits<dccl::int32>::max());
127 msg_in.set_int64_default_optional(std::numeric_limits<dccl::int64>::max());
128 msg_in.set_uint32_default_optional(std::numeric_limits<dccl::uint32>::max());
129 msg_in.set_uint64_default_optional(std::numeric_limits<dccl::uint64>::max());
130 msg_in.set_sint32_default_optional(std::numeric_limits<dccl::int32>::max());
131 msg_in.set_sint64_default_optional(std::numeric_limits<dccl::int64>::max());
132 msg_in.set_fixed32_default_optional(std::numeric_limits<dccl::uint32>::max());
133 msg_in.set_fixed64_default_optional(std::numeric_limits<dccl::uint64>::max());
134 msg_in.set_sfixed32_default_optional(std::numeric_limits<dccl::int32>::max());
135 msg_in.set_sfixed64_default_optional(std::numeric_limits<dccl::int64>::max());
136
137 msg_in.set_bool_default_optional(true);
138
139 msg_in.set_enum_default_optional(ENUM_C);
140
141 msg_in.set_double_default_required(std::numeric_limits<double>::max());
142 msg_in.set_float_default_required(std::numeric_limits<float>::max());
143 msg_in.set_int32_default_required(std::numeric_limits<dccl::int32>::max());
144 msg_in.set_int64_default_required(std::numeric_limits<dccl::int64>::max());
145 msg_in.set_uint32_default_required(std::numeric_limits<dccl::uint32>::max());
146 msg_in.set_uint64_default_required(std::numeric_limits<dccl::uint64>::max());
147 msg_in.set_sint32_default_required(std::numeric_limits<dccl::int32>::max());
148 msg_in.set_sint64_default_required(std::numeric_limits<dccl::int64>::max());
149 msg_in.set_fixed32_default_required(std::numeric_limits<dccl::uint32>::max());
150 msg_in.set_fixed64_default_required(std::numeric_limits<dccl::uint64>::max());
151 msg_in.set_sfixed32_default_required(std::numeric_limits<dccl::int32>::max());
152 msg_in.set_sfixed64_default_required(std::numeric_limits<dccl::int64>::max());
153
154 msg_in.set_bool_default_required(true);
155
156 msg_in.set_enum_default_required(ENUM_C);
157
158 for (int j = 0; j < 4; ++j)
159 {
160 msg_in.add_double_default_repeat(std::numeric_limits<double>::max());
161 msg_in.add_int32_default_repeat(std::numeric_limits<dccl::int32>::max());
162 }
163}
164
165void fill_message_min(NativeProtobufTest& msg_in)
166{
167 msg_in.set_double_default_optional(std::numeric_limits<double>::min());
168 msg_in.set_float_default_optional(std::numeric_limits<float>::min());
169
170 msg_in.set_int32_default_optional(std::numeric_limits<dccl::int32>::min());
171 msg_in.set_int64_default_optional(std::numeric_limits<dccl::int64>::min());
172 msg_in.set_uint32_default_optional(std::numeric_limits<dccl::uint32>::min());
173 msg_in.set_uint64_default_optional(std::numeric_limits<dccl::uint64>::min());
174 msg_in.set_sint32_default_optional(std::numeric_limits<dccl::int32>::min());
175 msg_in.set_sint64_default_optional(std::numeric_limits<dccl::int64>::min());
176 msg_in.set_fixed32_default_optional(std::numeric_limits<dccl::uint32>::min());
177 msg_in.set_fixed64_default_optional(std::numeric_limits<dccl::uint64>::min());
178 msg_in.set_sfixed32_default_optional(std::numeric_limits<dccl::int32>::min());
179 msg_in.set_sfixed64_default_optional(std::numeric_limits<dccl::int64>::min());
180
181 msg_in.set_bool_default_optional(true);
182
183 msg_in.set_enum_default_optional(ENUM_A);
184
185 msg_in.set_double_default_required(std::numeric_limits<double>::min());
186 msg_in.set_float_default_required(std::numeric_limits<float>::min());
187 msg_in.set_int32_default_required(std::numeric_limits<dccl::int32>::min());
188 msg_in.set_int64_default_required(std::numeric_limits<dccl::int64>::min());
189 msg_in.set_uint32_default_required(std::numeric_limits<dccl::uint32>::min());
190 msg_in.set_uint64_default_required(std::numeric_limits<dccl::uint64>::min());
191 msg_in.set_sint32_default_required(std::numeric_limits<dccl::int32>::min());
192 msg_in.set_sint64_default_required(std::numeric_limits<dccl::int64>::min());
193 msg_in.set_fixed32_default_required(std::numeric_limits<dccl::uint32>::min());
194 msg_in.set_fixed64_default_required(std::numeric_limits<dccl::uint64>::min());
195 msg_in.set_sfixed32_default_required(std::numeric_limits<dccl::int32>::min());
196 msg_in.set_sfixed64_default_required(std::numeric_limits<dccl::int64>::min());
197
198 msg_in.set_bool_default_required(true);
199
200 msg_in.set_enum_default_required(ENUM_A);
201
202 for (int j = 0; j < 4; ++j)
203 {
204 msg_in.add_double_default_repeat(std::numeric_limits<double>::min());
205 msg_in.add_int32_default_repeat(std::numeric_limits<dccl::int32>::min());
206 }
207}
208
209void run_test(dccl::Codec& codec, NativeProtobufTest& msg_in)
210{
211 NativeProtobufTest msg_out;
212 std::cout << "Message in:\n" << msg_in.DebugString() << std::endl;
213 std::cout << "Try encode..." << std::endl;
214 std::string bytes;
215 codec.encode(&bytes, msg_in);
216 std::cout << "... got bytes (hex): " << dccl::hex_encode(bytes) << std::endl;
217 std::cout << "Try decode..." << std::endl;
218 codec.decode(bytes, &msg_out);
219 std::cout << "... got Message out:\n" << msg_out.DebugString() << std::endl;
220
221 assert(msg_in.SerializeAsString() == msg_out.SerializeAsString());
222}
223
224int main(int /*argc*/, char* /*argv*/ [])
225{
226 dccl::dlog.connect(dccl::logger::ALL, &std::cerr);
227
228 dccl::Codec codec;
229 codec.load_library(DCCL_NATIVE_PROTOBUF_NAME);
230
231 codec.load<NativeProtobufTest>();
232 codec.info<NativeProtobufTest>(&dccl::dlog);
233
234 {
235 NativeProtobufTest msg_in;
236 fill_message(msg_in);
237 run_test(codec, msg_in);
238 }
239 {
240 NativeProtobufTest msg_in;
241 fill_message_partial(msg_in);
242 run_test(codec, msg_in);
243 }
244 {
245 NativeProtobufTest msg_in;
246 fill_message_min(msg_in);
247 run_test(codec, msg_in);
248 }
249
250 {
251 NativeProtobufTest msg_in;
252 fill_message_max(msg_in);
253 run_test(codec, msg_in);
254 }
255
256 std::cout << "all tests passed" << std::endl;
257}
dccl::Codec
The Dynamic CCL enCODer/DECoder. This is the main class you will use to load, encode and decode DCCL ...
Definition codec.h:63
dccl::Logger::connect
void connect(int verbosity_mask, Slot slot)
Connect the output of one or more given verbosities to a slot (function pointer or similar)
Definition logger.h:214
dccl::native_protobuf::EnumFieldCodec
Definition dccl_native_protobuf.h:396
dccl::test
Unit test namespace.
Definition test.cpp:45
dccl::hex_encode
void hex_encode(CharIterator begin, CharIterator end, std::string *out, bool upper_case=false)
Encodes a (little-endian) hexadecimal string from a byte string. Index 0 of begin is written to index...
Definition binary.h:100