DCCL v5
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 "../../ccl/ccl_compatibility.h"
27#include "../../codec.h"
28#include "../../field_codec.h"
29#include "test.pb.h"
30
31using namespace dccl::test;
32
33using dccl::operator<<;
34
35bool double_cmp(double a, double b, int precision)
36{
37 int a_whole = a;
38 int b_whole = b;
39
40 int a_part = (a - a_whole) * pow(10.0, precision);
41 int b_part = (b - b_whole) * pow(10.0, precision);
42
43 return (a_whole == b_whole) && (a_part == b_part);
44}
45
46template <typename N> void check_normal_dccl(dccl::Codec& codec)
47{
48 codec.load<N>();
49 codec.info<N>(&dccl::dlog);
50 N normal_msg, normal_msg_out;
51 normal_msg.set_a(123);
52 normal_msg.set_b(321);
53
54 std::string encoded;
55 codec.encode(&encoded, normal_msg);
56 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << dccl::hex_encode(encoded) << std::endl;
57 assert(dccl::hex_encode(encoded).substr(0, 2) == "20");
58 codec.decode(encoded, &normal_msg_out);
59
60 assert(normal_msg.SerializeAsString() == normal_msg_out.SerializeAsString());
61}
62
63int main(int argc, char* argv[])
64{
65 bool verbose = false;
66 for (int i = 1; i < argc; ++i)
67 {
68 if (argv[i] && argv[i][0] == '-' && argv[i][1] == 'v' && argv[i][2] == '\0')
69 verbose = true;
70 }
71
72 dccl::dlog.connect(verbose ? dccl::logger::ALL : dccl::logger::WARN_PLUS, &std::cerr);
73
74 dccl::Codec codec("dccl.ccl.id", DCCL_CCL_COMPAT_NAME);
75
76 check_normal_dccl<NormalDCCL1Byte>(codec);
77 check_normal_dccl<NormalDCCL2Byte>(codec);
78
79 codec.info<dccl::legacyccl::protobuf::CCLMDATState>(&dccl::dlog);
80
81 dccl::legacyccl::protobuf::CCLMDATState state_in, state_out;
82 std::string test_state_encoded =
83 "0e86fa11ad20c9011b4432bf47d10000002401042f0e7d87fa111620c95a200a";
84 codec.decode(dccl::hex_decode(test_state_encoded), &state_out);
85 state_in.set_latitude(25.282416667);
86 state_in.set_longitude(-77.164266667);
87 state_in.set_fix_age(4);
88
89 auto now = std::chrono::system_clock::now();
90 std::time_t now_time_t = std::chrono::system_clock::to_time_t(now);
91 std::tm input_tm = *std::gmtime(&now_time_t); // get current year
92 input_tm.tm_mon = 2; // zero indexed March
93 input_tm.tm_mday = 4;
94 input_tm.tm_hour = 17;
95 input_tm.tm_min = 1;
96 input_tm.tm_sec = 44;
97 input_tm.tm_isdst = -1;
98 std::time_t time_date = timegm(&input_tm);
99
100 state_in.set_time_date(dccl::legacyccl::TimeDateCodec::to_uint64_time(time_date));
101 state_in.set_heading(270);
102 state_in.set_depth(2323);
103 state_in.set_mission_mode(dccl::legacyccl::protobuf::CCLMDATState::NORMAL);
104 state_in.set_faults(dccl::hex_decode("00000024"));
105 state_in.set_faults_2(dccl::hex_decode("01"));
106 state_in.set_mission_leg(4);
107 state_in.set_est_velocity(1.88);
108 state_in.set_objective_index(dccl::hex_decode("0E"));
109 state_in.set_watts(500);
110 state_in.set_lat_goal(25.282440815262891);
111 state_in.set_lon_goal(-77.167505880296929);
112 state_in.set_battery_percent(90);
113 state_in.mutable_gfi_pitch_oil()->set_gfi(0);
114 state_in.mutable_gfi_pitch_oil()->set_pitch(6);
115 state_in.mutable_gfi_pitch_oil()->set_oil(55);
116
117 assert(double_cmp(state_in.latitude(), state_out.latitude(), 4));
118 assert(double_cmp(state_in.longitude(), state_out.longitude(), 4));
119 assert(state_in.fix_age() == state_out.fix_age());
120 assert(state_in.time_date() == state_out.time_date());
121 assert(dccl::round(state_in.heading(), 0) == dccl::round(state_out.heading(), 0));
122 assert(double_cmp(state_in.depth(), state_out.depth(), 1));
123 assert(state_in.mission_mode() == state_out.mission_mode());
124
125 // test the dynamically generated message
126 std::shared_ptr<google::protobuf::Message> state_in_2 =
127 dccl::DynamicProtobufManager::new_protobuf_message(
128 dccl::legacyccl::protobuf::CCLMDATState::descriptor());
129 state_in_2->CopyFrom(state_in);
130
131 std::string state_encoded;
132 codec.encode(&state_encoded, *state_in_2);
133
134 dccl::legacyccl::protobuf::CCLMDATState state_out_2;
135 codec.decode(state_encoded, &state_out_2);
136
137 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "in:" << state_in << std::endl;
138 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << test_state_encoded << std::endl;
139 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << dccl::hex_encode(state_encoded) << std::endl;
140 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << std::setprecision(16) << state_out.lon_goal() << std::endl;
141 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "out:" << state_out << std::endl;
142 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "out2: " << state_out_2 << std::endl;
143
144 assert(state_out.SerializeAsString() == state_out_2.SerializeAsString());
145 assert(test_state_encoded == dccl::hex_encode(state_encoded));
146
147 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << dccl::hex_encode(state_out.faults()) << std::endl;
148 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << dccl::hex_encode(state_out.faults_2()) << std::endl;
149
150 codec.info<dccl::legacyccl::protobuf::CCLMDATRedirect>(&dccl::dlog);
151
152 dccl::legacyccl::protobuf::CCLMDATRedirect redirect_in, redirect_out;
153 std::string test_redirect_encoded =
154 "07522cf9113d20c99964003d6464003d640be60014142035f911ef21c9000000";
155 codec.decode(dccl::hex_decode(test_redirect_encoded), &redirect_out);
156 redirect_in.set_message_number(82);
157 redirect_in.set_latitude(25.274995002149939);
158 redirect_in.set_longitude(-77.166669030984522);
159 redirect_in.set_transit_vertical_mode(dccl::legacyccl::protobuf::CCLMDATRedirect::ALTITUDE);
160 redirect_in.set_transit_thrust_mode(
161 dccl::legacyccl::protobuf::CCLMDATRedirect::METERS_PER_SECOND);
162 redirect_in.set_survey_vertical_mode(dccl::legacyccl::protobuf::CCLMDATRedirect::ALTITUDE);
163 redirect_in.set_survey_thrust_mode(
164 dccl::legacyccl::protobuf::CCLMDATRedirect::METERS_PER_SECOND);
165
166 redirect_in.set_depth_goal_transit(10.0);
167 redirect_in.set_speed_transit(2.0333333);
168 redirect_in.set_device_cmd_transit(100);
169
170 redirect_in.set_depth_goal_survey(10.0);
171 redirect_in.set_speed_survey(2.0333333);
172 redirect_in.set_device_cmd_survey(100);
173
174 redirect_in.set_num_rows(11);
175 redirect_in.set_row_length(230);
176 redirect_in.set_spacing_0(20);
177 redirect_in.set_spacing_1(20);
178 redirect_in.set_heading(45.176472);
179
180 redirect_in.set_lat_start(25.275183333);
181 redirect_in.set_lon_start(-77.15735);
182
183 redirect_in.set_spare(std::string(3, '\0'));
184
185 std::string redirect_encoded;
186 codec.encode(&redirect_encoded, redirect_in);
187
188 dccl::legacyccl::protobuf::CCLMDATRedirect redirect_out_2;
189 codec.decode(redirect_encoded, &redirect_out_2);
190
191 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "in:" << redirect_in << std::endl;
192 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << test_redirect_encoded << std::endl;
193 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << dccl::hex_encode(redirect_encoded) << std::endl;
194 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "out:" << redirect_out << std::endl;
195 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "out2: " << redirect_out_2 << std::endl;
196
197 assert(redirect_out.SerializeAsString() == redirect_out_2.SerializeAsString());
198 assert(test_redirect_encoded == dccl::hex_encode(redirect_encoded));
199
200 codec.info<dccl::legacyccl::protobuf::CCLMDATEmpty>(&dccl::dlog);
201 codec.info<dccl::legacyccl::protobuf::CCLMDATBathy>(&dccl::dlog);
202 codec.info<dccl::legacyccl::protobuf::CCLMDATCTD>(&dccl::dlog);
203 codec.info<dccl::legacyccl::protobuf::CCLMDATError>(&dccl::dlog);
204 codec.info<dccl::legacyccl::protobuf::CCLMDATCommand>(&dccl::dlog);
205
206 dccl::dlog.is(dccl::logger::INFO) && dccl::dlog << "all tests passed" << std::endl;
207}
dccl::Codec
The Dynamic CCL enCODer/DECoder. This is the main class you will use to load, encode and decode DCCL ...
Definition codec.h:61
dccl::DynamicProtobufManager::new_protobuf_message
static GoogleProtobufMessagePointer new_protobuf_message(const std::string &protobuf_type_name, bool user_pool_first=false)
Create a new (empty) Google Protobuf message of a given type by name.
Definition dynamic_protobuf_manager.h:74
dccl::Logger::is
bool is(logger::Verbosity verbosity, logger::Group group=logger::GENERAL)
Indicates the verbosity of the Logger until the next std::flush or std::endl. The boolean return is u...
Definition logger.h:191
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:213
dccl::test
Unit test namespace.
Definition test.cpp:45
dccl
Dynamic Compact Control Language namespace.
Definition any.h:28
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:95
dccl::hex_decode
void hex_decode(const std::string &in, std::string *out)
Decodes a (little-endian) hexadecimal string to a byte string. Index 0 and 1 (first byte) of in are w...
Definition binary.h:46