1 #include <gtest/gtest.h> 37 TEST(MemoryBocksParser, ParseAttitudeAndHeading)
42 const std::vector<uint8_t> memory{
43 0x3f, 0xa0, 0x00, 0x00,
44 0x41, 0x48, 0xcc, 0xcd,
45 0xbf, 0xc0, 0x00, 0x00
48 auto buffer = boost::asio::buffer(memory.data(), memory.size());
52 parser.parse(buffer, binaryNav);
60 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
63 TEST(MemoryBocksParser, ParseAttitudeAndHeadingDeviation)
68 const std::vector<uint8_t> memory{
69 0x3f, 0xa0, 0x00, 0x00,
70 0x41, 0x48, 0xcc, 0xcd,
74 auto buffer = boost::asio::buffer(memory.data(), memory.size());
78 parser.parse(buffer, binaryNav);
86 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
89 TEST(MemoryBocksParser, ParseRealTimeHeaveSurgeSway)
94 const std::vector<uint8_t> memory{
95 0x3f, 0xa0, 0x00, 0x00,
96 0x41, 0x48, 0xcc, 0xcd,
97 0xbf, 0xc0, 0x00, 0x00,
98 0xbb, 0xa3, 0xd7, 0x0a
101 auto buffer = boost::asio::buffer(memory.data(), memory.size());
105 parser.parse(buffer, binaryNav);
108 ASSERT_FLOAT_EQ(1.25, binaryNav.
rtHeaveSurgeSway.get().rt_heave_withoutBdL);
114 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
122 const std::vector<uint8_t> memory{
123 0x00, 0x00, 0x00, 0x7D,
124 0x3f, 0xa0, 0x00, 0x00,
127 auto buffer = boost::asio::buffer(memory.data(), memory.size());
131 parser.parse(buffer, binaryNav);
133 ASSERT_TRUE(binaryNav.
smartHeave.is_initialized());
134 ASSERT_FLOAT_EQ(1.25, binaryNav.
smartHeave.get().smartHeave_m);
135 ASSERT_EQ(125, binaryNav.
smartHeave.get().validityTime_100us);
138 TEST(MemoryBocksParser, ParseHeadingRollPitchRate)
143 const std::vector<uint8_t> memory{
144 0xbf, 0xc0, 0x00, 0x00,
145 0x3f, 0xa0, 0x00, 0x00,
146 0x41, 0x48, 0xcc, 0xcd
149 auto buffer = boost::asio::buffer(memory.data(), memory.size());
153 parser.parse(buffer, binaryNav);
161 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
164 TEST(MemoryBocksParser, ParseRotationRateVesselFrame)
169 const std::vector<uint8_t> memory{
170 0xbf, 0xc0, 0x00, 0x00,
171 0x3f, 0xa0, 0x00, 0x00,
172 0x41, 0x48, 0xcc, 0xcd
175 auto buffer = boost::asio::buffer(memory.data(), memory.size());
179 parser.parse(buffer, binaryNav);
187 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
190 TEST(MemoryBocksParser, ParseAccelerationVesselFrame)
195 const std::vector<uint8_t> memory{
196 0xbf, 0xc0, 0x00, 0x00,
197 0x3f, 0xa0, 0x00, 0x00,
198 0x41, 0x48, 0xcc, 0xcd
201 auto buffer = boost::asio::buffer(memory.data(), memory.size());
205 parser.parse(buffer, binaryNav);
213 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
216 TEST(MemoryBocksParser, ParsePosition)
221 const std::vector<uint8_t> memory{
222 0x40, 0x39, 0xae, 0x14,
223 0x7a, 0xe1, 0x47, 0xae,
224 0xc0, 0x13, 0x00, 0x00,
225 0x00, 0x00, 0x00, 0x00,
227 0x43, 0x1a, 0x35, 0xc3
230 auto buffer = boost::asio::buffer(memory.data(), memory.size());
234 parser.parse(buffer, binaryNav);
236 ASSERT_TRUE(binaryNav.
position.is_initialized());
237 ASSERT_DOUBLE_EQ(25.68, binaryNav.
position.get().latitude_deg);
238 ASSERT_DOUBLE_EQ(-4.75, binaryNav.
position.get().longitude_deg);
239 ASSERT_EQ(1, binaryNav.
position.get().altitude_ref);
240 ASSERT_FLOAT_EQ(154.21, binaryNav.
position.get().altitude_m);
243 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
246 TEST(MemoryBocksParser, ParsePositionDeviation)
251 const std::vector<uint8_t> memory{
252 0x3f, 0xa0, 0x00, 0x00,
253 0x41, 0x48, 0xcc, 0xcd,
254 0xbf, 0xc0, 0x00, 0x00,
255 0xbb, 0xa3, 0xd7, 0x0a
258 auto buffer = boost::asio::buffer(memory.data(), memory.size());
262 parser.parse(buffer, binaryNav);
271 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
274 TEST(MemoryBocksParser, ParseSpeedGeographicFrame)
279 const std::vector<uint8_t> memory{
280 0xbf, 0xc0, 0x00, 0x00,
281 0x3f, 0xa0, 0x00, 0x00,
282 0x41, 0x48, 0xcc, 0xcd
285 auto buffer = boost::asio::buffer(memory.data(), memory.size());
289 parser.parse(buffer, binaryNav);
297 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
300 TEST(MemoryBocksParser, ParseSpeedGeographicFrameDeviation)
305 const std::vector<uint8_t> memory{
306 0xbf, 0xc0, 0x00, 0x00,
307 0x3f, 0xa0, 0x00, 0x00,
308 0x41, 0x48, 0xcc, 0xcd
311 auto buffer = boost::asio::buffer(memory.data(), memory.size());
315 parser.parse(buffer, binaryNav);
318 ASSERT_FLOAT_EQ(-1.5,
324 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
327 TEST(MemoryBocksParser, ParseCurrentGeographicFrameDeviation)
331 const std::vector<uint8_t> memory{
332 0xbf, 0xc0, 0x00, 0x00,
333 0x3f, 0xa0, 0x00, 0x00
336 auto buffer = boost::asio::buffer(memory.data(), memory.size());
340 parser.parse(buffer, binaryNav);
343 ASSERT_FLOAT_EQ(-1.5,
345 ASSERT_FLOAT_EQ(1.25,
349 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
352 TEST(MemoryBocksParser, ParseSystemDate)
356 const std::vector<uint8_t> memory{
362 auto buffer = boost::asio::buffer(memory.data(), memory.size());
366 parser.parse(buffer, binaryNav);
368 ASSERT_TRUE(binaryNav.
systemDate.is_initialized());
369 ASSERT_EQ(28, binaryNav.
systemDate.get().day);
370 ASSERT_EQ(8, binaryNav.
systemDate.get().month);
371 ASSERT_EQ(2020, binaryNav.
systemDate.get().year);
374 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
377 TEST(MemoryBocksParser, ParseSensorStatus)
381 const std::vector<uint8_t> memory{
382 0x00, 0x00, 0x02, 0x14,
383 0x00, 0x00, 0x00, 0x11
386 auto buffer = boost::asio::buffer(memory.data(), memory.size());
390 parser.parse(buffer, binaryNav);
397 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
400 TEST(MemoryBocksParser, ParseINSAlgorithmStatus)
405 const std::vector<uint8_t> memory{
406 0x00, 0x00, 0x02, 0x14,
407 0x00, 0x00, 0x00, 0x2a,
408 0x00, 0x00, 0xba, 0xd2,
409 0x00, 0x00, 0x00, 0x11
412 auto buffer = boost::asio::buffer(memory.data(), memory.size());
416 parser.parse(buffer, binaryNav);
425 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
428 TEST(MemoryBocksParser, ParseINSSystemStatus)
433 const std::vector<uint8_t> memory{
434 0x00, 0x00, 0x02, 0x14,
435 0x00, 0x00, 0x00, 0x2a,
436 0x00, 0x00, 0xba, 0xd2
439 auto buffer = boost::asio::buffer(memory.data(), memory.size());
443 parser.parse(buffer, binaryNav);
451 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
454 TEST(MemoryBocksParser, ParseINSUserStatus)
458 const std::vector<uint8_t> memory{
459 0x00, 0x00, 0x02, 0x14,
462 auto buffer = boost::asio::buffer(memory.data(), memory.size());
466 parser.parse(buffer, binaryNav);
472 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
475 TEST(MemoryBocksParser, ParseAHRSAlgorithmStatus)
479 const std::vector<uint8_t> memory{
480 0x00, 0x00, 0x02, 0x14
483 auto buffer = boost::asio::buffer(memory.data(), memory.size());
487 parser.parse(buffer, binaryNav);
493 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
496 TEST(MemoryBocksParser, ParseAHRSSystemStatus)
501 const std::vector<uint8_t> memory{
502 0x00, 0x00, 0x02, 0x14,
503 0x00, 0x00, 0x00, 0x2a,
504 0x00, 0x00, 0xba, 0xd2
507 auto buffer = boost::asio::buffer(memory.data(), memory.size());
511 parser.parse(buffer, binaryNav);
519 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
522 TEST(MemoryBocksParser, ParseAHRSUserStatus)
526 const std::vector<uint8_t> memory{
527 0x00, 0x00, 0x02, 0x14
530 auto buffer = boost::asio::buffer(memory.data(), memory.size());
534 parser.parse(buffer, binaryNav);
540 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
543 TEST(MemoryBocksParser, ParseHeaveSurgeSwaySpeed)
548 const std::vector<uint8_t> memory{
549 0xbf, 0xc0, 0x00, 0x00,
550 0x3f, 0xa0, 0x00, 0x00,
551 0x41, 0x48, 0xcc, 0xcd
554 auto buffer = boost::asio::buffer(memory.data(), memory.size());
558 parser.parse(buffer, binaryNav);
566 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
569 TEST(MemoryBocksParser, ParseSpeedVesselFrame)
573 const std::vector<uint8_t> memory{
574 0xbf, 0xc0, 0x00, 0x00,
575 0x3f, 0xa0, 0x00, 0x00,
576 0x41, 0x48, 0xcc, 0xcd
579 auto buffer = boost::asio::buffer(memory.data(), memory.size());
583 parser.parse(buffer, binaryNav);
591 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
594 TEST(MemoryBocksParser, ParseAccelerationGeographicFrame)
598 const std::vector<uint8_t> memory{
599 0xbf, 0xc0, 0x00, 0x00,
600 0x3f, 0xa0, 0x00, 0x00,
601 0x41, 0x48, 0xcc, 0xcd
604 auto buffer = boost::asio::buffer(memory.data(), memory.size());
608 parser.parse(buffer, binaryNav);
616 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
619 TEST(MemoryBocksParser, ParseourseSpeedoverGrounde)
623 const std::vector<uint8_t> memory{
624 0xbf, 0xc0, 0x00, 0x00,
625 0x3f, 0xa0, 0x00, 0x00
628 auto buffer = boost::asio::buffer(memory.data(), memory.size());
632 parser.parse(buffer, binaryNav);
639 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
642 TEST(MemoryBocksParser, ParseTemperatures)
646 const std::vector<uint8_t> memory{
647 0xbf, 0xc0, 0x00, 0x00,
648 0x3f, 0xa0, 0x00, 0x00,
649 0x41, 0x48, 0xcc, 0xcd
652 auto buffer = boost::asio::buffer(memory.data(), memory.size());
656 parser.parse(buffer, binaryNav);
659 ASSERT_FLOAT_EQ(-1.5, binaryNav.
temperatures.get().mean_temp_fog);
660 ASSERT_FLOAT_EQ(1.25, binaryNav.
temperatures.get().mean_temp_acc);
661 ASSERT_FLOAT_EQ(12.55, binaryNav.
temperatures.get().board_temperature);
664 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
667 TEST(MemoryBocksParser, ParseAttitudeQuaternion)
672 const std::vector<uint8_t> memory{
673 0x3f, 0xa0, 0x00, 0x00,
674 0x41, 0x48, 0xcc, 0xcd,
675 0xbf, 0xc0, 0x00, 0x00,
676 0xbb, 0xa3, 0xd7, 0x0a
679 auto buffer = boost::asio::buffer(memory.data(), memory.size());
683 parser.parse(buffer, binaryNav);
692 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
695 TEST(MemoryBocksParser, ParseAttitudeQuaternionDeviation)
699 const std::vector<uint8_t> memory{
700 0xbf, 0xc0, 0x00, 0x00,
701 0x3f, 0xa0, 0x00, 0x00,
702 0x41, 0x48, 0xcc, 0xcd
705 auto buffer = boost::asio::buffer(memory.data(), memory.size());
709 parser.parse(buffer, binaryNav);
717 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
720 TEST(MemoryBocksParser, ParseRawAccelerationVesselFrame)
724 const std::vector<uint8_t> memory{
725 0xbf, 0xc0, 0x00, 0x00,
726 0x3f, 0xa0, 0x00, 0x00,
727 0x41, 0x48, 0xcc, 0xcd
730 auto buffer = boost::asio::buffer(memory.data(), memory.size());
734 parser.parse(buffer, binaryNav);
742 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
745 TEST(MemoryBocksParser, ParseAccelerationVesselFrameDeviation)
750 const std::vector<uint8_t> memory{
751 0xbf, 0xc0, 0x00, 0x00,
752 0x3f, 0xa0, 0x00, 0x00,
753 0x41, 0x48, 0xcc, 0xcd
756 auto buffer = boost::asio::buffer(memory.data(), memory.size());
760 parser.parse(buffer, binaryNav);
763 ASSERT_FLOAT_EQ(-1.5,
765 ASSERT_FLOAT_EQ(1.25,
767 ASSERT_FLOAT_EQ(12.55,
771 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
774 TEST(MemoryBocksParser, ParseRotationRateVesselFrameDeviation)
779 const std::vector<uint8_t> memory{
780 0xbf, 0xc0, 0x00, 0x00,
781 0x3f, 0xa0, 0x00, 0x00,
782 0x41, 0x48, 0xcc, 0xcd
785 auto buffer = boost::asio::buffer(memory.data(), memory.size());
789 parser.parse(buffer, binaryNav);
792 ASSERT_FLOAT_EQ(-1.5,
794 ASSERT_FLOAT_EQ(1.25,
796 ASSERT_FLOAT_EQ(12.55,
800 ASSERT_EQ(0, boost::asio::buffer_size(buffer));
803 int main(
int argc,
char** argv)
805 ::testing::InitGoogleTest(&argc, argv);
806 return RUN_ALL_TESTS();
boost::optional< CurrentGeographicFrameDeviation > currentGeographicFrameDeviation
boost::optional< SpeedVesselFrame > speedVesselFrame
boost::optional< AccelerationVesselFrameDeviation > accelerationVesselFrameDeviation
boost::optional< SystemDate > systemDate
boost::optional< INSSystemStatus > insSystemStatus
boost::optional< AccelerationVesselFrame > accelerationVesselFrame
boost::optional< INSAlgorithmStatus > insAlgorithmStatus
boost::optional< RotationRateVesselFrame > rotationRateVesselFrame
boost::optional< RawAccelerationVesselFrame > rawAccelerationVesselFrame
boost::optional< Position > position
boost::optional< HeaveSurgeSwaySpeed > heaveSurgeSwaySpeed
boost::optional< Temperatures > temperatures
boost::optional< PositionDeviation > positionDeviation
boost::optional< AttitudeQuaternion > attitudeQuaternion
boost::optional< SensorStatus > sensorStatus
boost::optional< INSUserStatus > insUserStatus
boost::optional< AHRSAlgorithmStatus > ahrsAlgorithmStatus
boost::optional< AttitudeQuaternionDeviation > attitudeQuaternionDeviation
boost::optional< CourseSpeedoverGround > courseSpeedoverGround
boost::optional< SpeedGeographicFrame > speedGeographicFrame
TEST(MemoryBocksParser, ParseAttitudeAndHeading)
boost::optional< RealTimeHeaveSurgeSway > rtHeaveSurgeSway
boost::optional< AttitudeHeading > attitudeHeading
int main(int argc, char **argv)
boost::optional< HeadingRollPitchRate > headingRollPitchRate
boost::optional< AttitudeHeadingDeviation > attitudeHeadingDeviation
boost::optional< AHRSUserStatus > ahrsUserStatus
boost::optional< SpeedGeographicFrameDeviation > speedGeographicFrameDeviation
boost::optional< RotationRateVesselFrameDeviation > rotationRateVesselFrameDeviation
boost::optional< AHRSSystemStatus > ahrsSystemStatus
boost::optional< AccelerationGeographicFrame > accelerationGeographicFrame
boost::optional< SmartHeave > smartHeave