DCCL v3
test.cpp
1 // Copyright 2009-2017 Toby Schneider (http://gobysoft.org/index.wt/people/toby)
2 // GobySoft, LLC (for 2013-)
3 // Massachusetts Institute of Technology (for 2007-2014)
4 // Community contributors (see AUTHORS file)
5 //
6 //
7 // This file is part of the Dynamic Compact Control Language Library
8 // ("DCCL").
9 //
10 // DCCL is free software: you can redistribute it and/or modify
11 // it under the terms of the GNU Lesser General Public License as published by
12 // the Free Software Foundation, either version 2.1 of the License, or
13 // (at your option) any later version.
14 //
15 // DCCL is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public License
21 // along with DCCL. If not, see <http://www.gnu.org/licenses/>.
22 // tests usage of Legacy CCL
23 
24 #include "test.pb.h"
25 #include "dccl.h"
26 #include "dccl/native_protobuf/dccl_native_protobuf.h"
27 
28 using namespace dccl::test;
29 
30 using dccl::operator<<;
31 
32 // ensure we link in dccl_native_protobuf.so
34 
35 
36 void 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 
76  for(int j = 0; j < 4; ++j)
77  {
78  msg_in.add_double_default_repeat(++i + 0.1);
79  msg_in.add_int32_default_repeat(++i);
80  }
81 }
82 
83 void fill_message_partial(NativeProtobufTest& msg_in)
84 {
85  int i = 0;
86  msg_in.set_double_default_optional(++i + 0.1);
87  msg_in.set_float_default_optional(++i + 0.2);
88 
89  msg_in.set_int32_default_optional(++i);
90  msg_in.set_uint32_default_optional(++i);
91  msg_in.set_uint64_default_optional(++i);
92  msg_in.set_sint64_default_optional(++i);
93  msg_in.set_fixed32_default_optional(++i);
94  msg_in.set_sfixed32_default_optional(++i);
95  msg_in.set_sfixed64_default_optional(-++i);
96 
97 
98  msg_in.set_double_default_required(++i + 0.1);
99  msg_in.set_float_default_required(++i + 0.2);
100 
101  msg_in.set_int32_default_required(++i);
102  msg_in.set_int64_default_required(-++i);
103  msg_in.set_uint32_default_required(++i);
104  msg_in.set_uint64_default_required(++i);
105  msg_in.set_sint32_default_required(-++i);
106  msg_in.set_sint64_default_required(++i);
107  msg_in.set_fixed32_default_required(++i);
108  msg_in.set_fixed64_default_required(++i);
109  msg_in.set_sfixed32_default_required(++i);
110  msg_in.set_sfixed64_default_required(-++i);
111 
112  msg_in.set_bool_default_required(true);
113 
114  msg_in.set_enum_default_required(ENUM_C);
115 
116 
117  for(int j = 0; j < 2; ++j)
118  {
119  msg_in.add_double_default_repeat(++i + 0.1);
120  msg_in.add_int32_default_repeat(++i);
121  }
122 }
123 
124 
125 void fill_message_max(NativeProtobufTest& msg_in)
126 {
127  msg_in.set_double_default_optional(std::numeric_limits<double>::max());
128  msg_in.set_float_default_optional(std::numeric_limits<float>::max());
129 
130  msg_in.set_int32_default_optional(std::numeric_limits<dccl::int32>::max());
131  msg_in.set_int64_default_optional(std::numeric_limits<dccl::int64>::max());
132  msg_in.set_uint32_default_optional(std::numeric_limits<dccl::uint32>::max());
133  msg_in.set_uint64_default_optional(std::numeric_limits<dccl::uint64>::max());
134  msg_in.set_sint32_default_optional(std::numeric_limits<dccl::int32>::max());
135  msg_in.set_sint64_default_optional(std::numeric_limits<dccl::int64>::max());
136  msg_in.set_fixed32_default_optional(std::numeric_limits<dccl::uint32>::max());
137  msg_in.set_fixed64_default_optional(std::numeric_limits<dccl::uint64>::max());
138  msg_in.set_sfixed32_default_optional(std::numeric_limits<dccl::int32>::max());
139  msg_in.set_sfixed64_default_optional(std::numeric_limits<dccl::int64>::max());
140 
141  msg_in.set_bool_default_optional(true);
142 
143  msg_in.set_enum_default_optional(ENUM_C);
144 
145  msg_in.set_double_default_required(std::numeric_limits<double>::max());
146  msg_in.set_float_default_required(std::numeric_limits<float>::max());
147  msg_in.set_int32_default_required(std::numeric_limits<dccl::int32>::max());
148  msg_in.set_int64_default_required(std::numeric_limits<dccl::int64>::max());
149  msg_in.set_uint32_default_required(std::numeric_limits<dccl::uint32>::max());
150  msg_in.set_uint64_default_required(std::numeric_limits<dccl::uint64>::max());
151  msg_in.set_sint32_default_required(std::numeric_limits<dccl::int32>::max());
152  msg_in.set_sint64_default_required(std::numeric_limits<dccl::int64>::max());
153  msg_in.set_fixed32_default_required(std::numeric_limits<dccl::uint32>::max());
154  msg_in.set_fixed64_default_required(std::numeric_limits<dccl::uint64>::max());
155  msg_in.set_sfixed32_default_required(std::numeric_limits<dccl::int32>::max());
156  msg_in.set_sfixed64_default_required(std::numeric_limits<dccl::int64>::max());
157 
158  msg_in.set_bool_default_required(true);
159 
160  msg_in.set_enum_default_required(ENUM_C);
161 
162 
163  for(int j = 0; j < 4; ++j)
164  {
165  msg_in.add_double_default_repeat(std::numeric_limits<double>::max());
166  msg_in.add_int32_default_repeat(std::numeric_limits<dccl::int32>::max());
167  }
168 }
169 
170 
171 void fill_message_min(NativeProtobufTest& msg_in)
172 {
173  msg_in.set_double_default_optional(std::numeric_limits<double>::min());
174  msg_in.set_float_default_optional(std::numeric_limits<float>::min());
175 
176  msg_in.set_int32_default_optional(std::numeric_limits<dccl::int32>::min());
177  msg_in.set_int64_default_optional(std::numeric_limits<dccl::int64>::min());
178  msg_in.set_uint32_default_optional(std::numeric_limits<dccl::uint32>::min());
179  msg_in.set_uint64_default_optional(std::numeric_limits<dccl::uint64>::min());
180  msg_in.set_sint32_default_optional(std::numeric_limits<dccl::int32>::min());
181  msg_in.set_sint64_default_optional(std::numeric_limits<dccl::int64>::min());
182  msg_in.set_fixed32_default_optional(std::numeric_limits<dccl::uint32>::min());
183  msg_in.set_fixed64_default_optional(std::numeric_limits<dccl::uint64>::min());
184  msg_in.set_sfixed32_default_optional(std::numeric_limits<dccl::int32>::min());
185  msg_in.set_sfixed64_default_optional(std::numeric_limits<dccl::int64>::min());
186 
187  msg_in.set_bool_default_optional(true);
188 
189  msg_in.set_enum_default_optional(ENUM_A);
190 
191  msg_in.set_double_default_required(std::numeric_limits<double>::min());
192  msg_in.set_float_default_required(std::numeric_limits<float>::min());
193  msg_in.set_int32_default_required(std::numeric_limits<dccl::int32>::min());
194  msg_in.set_int64_default_required(std::numeric_limits<dccl::int64>::min());
195  msg_in.set_uint32_default_required(std::numeric_limits<dccl::uint32>::min());
196  msg_in.set_uint64_default_required(std::numeric_limits<dccl::uint64>::min());
197  msg_in.set_sint32_default_required(std::numeric_limits<dccl::int32>::min());
198  msg_in.set_sint64_default_required(std::numeric_limits<dccl::int64>::min());
199  msg_in.set_fixed32_default_required(std::numeric_limits<dccl::uint32>::min());
200  msg_in.set_fixed64_default_required(std::numeric_limits<dccl::uint64>::min());
201  msg_in.set_sfixed32_default_required(std::numeric_limits<dccl::int32>::min());
202  msg_in.set_sfixed64_default_required(std::numeric_limits<dccl::int64>::min());
203 
204  msg_in.set_bool_default_required(true);
205 
206  msg_in.set_enum_default_required(ENUM_A);
207 
208 
209  for(int j = 0; j < 4; ++j)
210  {
211  msg_in.add_double_default_repeat(std::numeric_limits<double>::min());
212  msg_in.add_int32_default_repeat(std::numeric_limits<dccl::int32>::min());
213  }
214 }
215 
216 
217 void run_test(dccl::Codec& codec, NativeProtobufTest& msg_in)
218 {
219  NativeProtobufTest msg_out;
220  std::cout << "Message in:\n" << msg_in.DebugString() << std::endl;
221  std::cout << "Try encode..." << std::endl;
222  std::string bytes;
223  codec.encode(&bytes, msg_in);
224  std::cout << "... got bytes (hex): " << dccl::hex_encode(bytes) << std::endl;
225  std::cout << "Try decode..." << std::endl;
226  codec.decode(bytes, &msg_out);
227  std::cout << "... got Message out:\n" << msg_out.DebugString() << std::endl;
228 
229  assert(msg_in.SerializeAsString() == msg_out.SerializeAsString());
230 }
231 
232 
233 int main(int argc, char* argv[])
234 {
235  dccl::dlog.connect(dccl::logger::ALL, &std::cerr);
236 
237  dccl::Codec codec;
238  codec.load_library(DCCL_NATIVE_PROTOBUF_NAME);
239 
240  codec.load<NativeProtobufTest>();
241  codec.info<NativeProtobufTest>(&dccl::dlog);
242 
243  {
244  NativeProtobufTest msg_in;
245  fill_message(msg_in);
246  run_test(codec, msg_in);
247  }
248  {
249  NativeProtobufTest msg_in;
250  fill_message_partial(msg_in);
251  run_test(codec, msg_in);
252  }
253  {
254  NativeProtobufTest msg_in;
255  fill_message_min(msg_in);
256  run_test(codec, msg_in);
257  }
258 
259 
260  {
261  NativeProtobufTest msg_in;
262  fill_message_max(msg_in);
263  run_test(codec, msg_in);
264  }
265 
266 
267 
268  std::cout << "all tests passed" << std::endl;
269 }
270 
The Dynamic CCL enCODer/DECoder. This is the main class you will use to load, encode and decode DCCL ...
Definition: codec.h:56
void info(std::ostream *os=0, int user_id=-1) const
Writes a human readable summary (including field sizes) of the provided DCCL type to the stream provi...
Definition: codec.h:155
void load()
All messages must be explicited loaded and validated (size checks, option extensions checks...
Definition: codec.h:96
void encode(std::string *bytes, const google::protobuf::Message &msg, bool header_only=false, int user_id=-1)
Encodes a DCCL message.
Definition: codec.cpp:283
void load_library(void *dl_handle)
Add codecs and/or load messages present in the given shared library handle.
Definition: codec.cpp:616
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:161
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
Unit test namespace.
Definition: test.cpp:44
CharIterator decode(CharIterator begin, CharIterator end, google::protobuf::Message *msg, bool header_only=false)
Decode a DCCL message when the type is known at compile time.
Definition: codec.h:439