├── .clang-format ├── .cppcheck-excludes ├── .gitignore ├── .gitmodules ├── .reword ├── CONTRIBUTORS.md ├── INSTALL.md ├── Jenkinsfile ├── LICENSE ├── Makefile ├── README.md ├── VERSION ├── doc ├── doxygen │ ├── doxyfile │ └── doxyfile-internal ├── images │ ├── OUTPOST_logo.png │ ├── OUTPOST_logo.svg │ └── sw_layers.svg ├── lbuild │ ├── .gitignore │ ├── Makefile │ ├── check_dependencies.py │ └── project.xml └── style │ ├── eclipse_outpost_codetemplates.xml │ └── eclipse_outpost_formatter_style.xml ├── ext ├── README.md ├── SConscript ├── SConscript.gsl ├── googletest-1.12.1-fused │ ├── gmock-gtest-all.cc │ ├── gmock │ │ └── gmock.h │ └── gtest │ │ └── gtest.h ├── gsl │ ├── .clang-format │ ├── .gitignore │ ├── .travis.yml │ ├── CMakeLists.txt │ ├── CONTRIBUTING.md │ ├── GSL.natvis │ ├── LICENSE │ ├── README.md │ ├── gsl │ │ ├── gsl │ │ ├── gsl_algorithm │ │ ├── gsl_assert │ │ ├── gsl_byte │ │ ├── gsl_config.hpp │ │ ├── gsl_util │ │ ├── multi_span │ │ ├── span │ │ ├── stdex │ │ │ ├── LICENSE.TXT │ │ │ ├── algorithm.hpp │ │ │ ├── iterator.hpp │ │ │ └── type_traits.hpp │ │ └── string_span │ └── tests │ │ ├── CMakeLists.txt │ │ ├── algorithm_tests.cpp │ │ ├── assertion_tests.cpp │ │ ├── at_tests.cpp │ │ ├── bounds_tests.cpp │ │ ├── byte_tests.cpp │ │ ├── multi_span_tests.cpp │ │ ├── notnull_tests.cpp │ │ ├── owner_tests.cpp │ │ ├── span_tests.cpp │ │ ├── strided_span_tests.cpp │ │ ├── string_span_tests.cpp │ │ └── utils_tests.cpp ├── icecream-0.3.1 │ ├── AUTHORS │ ├── CMakeLists.txt │ ├── LICENSE.txt │ ├── README.md │ ├── catch.hpp │ ├── icecream.hpp │ ├── meson.build │ ├── test.cpp │ └── test_2.cpp ├── module.lb └── rapidcheck │ ├── .clang-format │ ├── .dir-locals.el │ ├── .gitignore │ ├── .gitmodules │ ├── .travis.yml │ ├── CMakeLists.txt │ ├── LICENSE.md │ ├── README.md │ ├── appveyor.yml │ ├── doc │ ├── Gen.md │ ├── Seq.md │ ├── Shrinkable.md │ ├── assertions.md │ ├── boost.md │ ├── boost_test.md │ ├── configuration.md │ ├── debugging.md │ ├── displaying.md │ ├── distribution.md │ ├── generators.md │ ├── generators_ref.md │ ├── gmock.md │ ├── gtest.md │ ├── properties.md │ ├── state.md │ ├── state_ref.md │ └── user_guide.md │ ├── examples │ ├── CMakeLists.txt │ ├── boost_test │ │ ├── CMakeLists.txt │ │ └── main.cpp │ ├── classify │ │ ├── CMakeLists.txt │ │ └── main.cpp │ ├── counter │ │ ├── CMakeLists.txt │ │ └── main.cpp │ ├── database │ │ ├── CMakeLists.txt │ │ ├── Database.cpp │ │ ├── Database.h │ │ ├── DatabaseConnection.cpp │ │ ├── DatabaseConnection.h │ │ ├── Generators.h │ │ ├── User.cpp │ │ ├── User.h │ │ └── main.cpp │ ├── gtest │ │ ├── CMakeLists.txt │ │ └── main.cpp │ └── mapparser │ │ ├── CMakeLists.txt │ │ ├── MapParser.cpp │ │ ├── MapParser.h │ │ └── main.cpp │ ├── ext │ ├── CMakeLists.txt │ └── get_boost.sh │ ├── extras │ ├── CMakeLists.txt │ ├── boost │ │ ├── CMakeLists.txt │ │ ├── include │ │ │ └── rapidcheck │ │ │ │ ├── boost.h │ │ │ │ └── gen │ │ │ │ └── boost │ │ │ │ ├── Optional.h │ │ │ │ └── Optional.hpp │ │ └── test │ │ │ ├── CMakeLists.txt │ │ │ ├── OptionalTests.cpp │ │ │ └── main.cpp │ ├── boost_test │ │ ├── CMakeLists.txt │ │ └── include │ │ │ └── rapidcheck │ │ │ └── boost_test.h │ ├── catch │ │ ├── CMakeLists.txt │ │ └── include │ │ │ └── rapidcheck │ │ │ └── catch.h │ ├── gmock │ │ ├── CMakeLists.txt │ │ ├── include │ │ │ └── rapidcheck │ │ │ │ └── gmock.h │ │ └── test │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ └── gtest │ │ ├── CMakeLists.txt │ │ └── include │ │ └── rapidcheck │ │ └── gtest.h │ ├── include │ ├── rapidcheck.h │ └── rapidcheck │ │ ├── Assertions.h │ │ ├── Assertions.hpp │ │ ├── BeforeMinimalTestCase.h │ │ ├── Check.h │ │ ├── Check.hpp │ │ ├── Classify.h │ │ ├── Classify.hpp │ │ ├── Gen.h │ │ ├── Gen.hpp │ │ ├── GenerationFailure.h │ │ ├── Log.h │ │ ├── Log.hpp │ │ ├── Maybe.h │ │ ├── Maybe.hpp │ │ ├── Nothing.h │ │ ├── Random.h │ │ ├── Random.hpp │ │ ├── Seq.h │ │ ├── Seq.hpp │ │ ├── Show.h │ │ ├── Show.hpp │ │ ├── Shrinkable.h │ │ ├── Shrinkable.hpp │ │ ├── Traits.h │ │ ├── detail │ │ ├── AlignedUnion.h │ │ ├── Any.h │ │ ├── Any.hpp │ │ ├── ApplyTuple.h │ │ ├── BitStream.h │ │ ├── BitStream.hpp │ │ ├── Capture.h │ │ ├── Configuration.h │ │ ├── ExecFixture.h │ │ ├── FrequencyMap.h │ │ ├── FunctionTraits.h │ │ ├── ImplicitParam.h │ │ ├── ImplicitParam.hpp │ │ ├── IntSequence.h │ │ ├── Platform.h │ │ ├── Property.h │ │ ├── Property.hpp │ │ ├── PropertyContext.h │ │ ├── Results.h │ │ ├── Results.hpp │ │ ├── Serialization.h │ │ ├── Serialization.hpp │ │ ├── ShowType.h │ │ ├── ShowType.hpp │ │ ├── TestListener.h │ │ ├── TestListenerAdapter.h │ │ ├── TestMetadata.h │ │ ├── TestParams.h │ │ ├── Traits.h │ │ ├── TypeList.h │ │ ├── Utility.h │ │ ├── Variant.h │ │ └── Variant.hpp │ │ ├── fn │ │ ├── Common.h │ │ └── Common.hpp │ │ ├── gen │ │ ├── Arbitrary.h │ │ ├── Arbitrary.hpp │ │ ├── Build.h │ │ ├── Build.hpp │ │ ├── Chrono.h │ │ ├── Chrono.hpp │ │ ├── Container.h │ │ ├── Container.hpp │ │ ├── Create.h │ │ ├── Create.hpp │ │ ├── Exec.h │ │ ├── Exec.hpp │ │ ├── Maybe.h │ │ ├── Maybe.hpp │ │ ├── Numeric.h │ │ ├── Numeric.hpp │ │ ├── Predicate.h │ │ ├── Predicate.hpp │ │ ├── Select.h │ │ ├── Select.hpp │ │ ├── Text.h │ │ ├── Text.hpp │ │ ├── Transform.h │ │ ├── Transform.hpp │ │ ├── Tuple.h │ │ ├── Tuple.hpp │ │ └── detail │ │ │ ├── ExecHandler.h │ │ │ ├── ExecRaw.h │ │ │ ├── ExecRaw.hpp │ │ │ ├── GenerationHandler.h │ │ │ ├── Recipe.h │ │ │ ├── ScaleInteger.h │ │ │ ├── ShrinkValueIterator.h │ │ │ └── ShrinkValueIterator.hpp │ │ ├── seq │ │ ├── Create.h │ │ ├── Create.hpp │ │ ├── Operations.h │ │ ├── Operations.hpp │ │ ├── SeqIterator.h │ │ ├── SeqIterator.hpp │ │ ├── Transform.h │ │ └── Transform.hpp │ │ ├── shrink │ │ ├── Shrink.h │ │ └── Shrink.hpp │ │ ├── shrinkable │ │ ├── Create.h │ │ ├── Create.hpp │ │ ├── Operations.h │ │ ├── Operations.hpp │ │ ├── Transform.h │ │ └── Transform.hpp │ │ ├── state.h │ │ └── state │ │ ├── Command.h │ │ ├── Command.hpp │ │ ├── Commands.h │ │ ├── Commands.hpp │ │ ├── State.h │ │ ├── State.hpp │ │ └── gen │ │ ├── Commands.h │ │ ├── Commands.hpp │ │ ├── ExecCommands.h │ │ └── ExecCommands.hpp │ ├── src │ ├── BeforeMinimalTestCase.cpp │ ├── Check.cpp │ ├── Classify.cpp │ ├── GenerationFailure.cpp │ ├── Log.cpp │ ├── Random.cpp │ ├── Show.cpp │ ├── detail │ │ ├── Any.cpp │ │ ├── Assertions.cpp │ │ ├── Base64.cpp │ │ ├── Base64.h │ │ ├── Configuration.cpp │ │ ├── DefaultTestListener.cpp │ │ ├── DefaultTestListener.h │ │ ├── FrequencyMap.cpp │ │ ├── ImplicitParam.cpp │ │ ├── LogTestListener.cpp │ │ ├── LogTestListener.h │ │ ├── MapParser.cpp │ │ ├── MapParser.h │ │ ├── MulticastTestListener.cpp │ │ ├── MulticastTestListener.h │ │ ├── ParseException.cpp │ │ ├── ParseException.h │ │ ├── Platform.cpp │ │ ├── Property.cpp │ │ ├── PropertyContext.cpp │ │ ├── ReproduceListener.cpp │ │ ├── ReproduceListener.h │ │ ├── Results.cpp │ │ ├── Serialization.cpp │ │ ├── StringSerialization.cpp │ │ ├── StringSerialization.h │ │ ├── TestMetadata.cpp │ │ ├── TestParams.cpp │ │ ├── Testing.cpp │ │ └── Testing.h │ └── gen │ │ ├── Numeric.cpp │ │ ├── Text.cpp │ │ └── detail │ │ ├── ExecHandler.cpp │ │ ├── GenerationHandler.cpp │ │ ├── Recipe.cpp │ │ └── ScaleInteger.cpp │ └── test │ ├── AssertionsTests.cpp │ ├── CMakeLists.txt │ ├── CheckTests.cpp │ ├── ClassifyTests.cpp │ ├── GenTests.cpp │ ├── LogTests.cpp │ ├── MaybeTests.cpp │ ├── RandomTests.cpp │ ├── SeqTests.cpp │ ├── ShowTests.cpp │ ├── ShrinkableTests.cpp │ ├── detail │ ├── AnyTests.cpp │ ├── ApplyTupleTests.cpp │ ├── Base64Tests.cpp │ ├── BitStreamTests.cpp │ ├── CaptureTests.cpp │ ├── ConfigurationTests.cpp │ ├── DefaultTestListenerTests.cpp │ ├── FrequencyMapTests.cpp │ ├── ImplicitParamTests.cpp │ ├── LogTestListenerTests.cpp │ ├── MapParserTests.cpp │ ├── MulticastTestListenerTests.cpp │ ├── PropertyTests.cpp │ ├── ReproduceListenerTests.cpp │ ├── ResultsTests.cpp │ ├── SerializationTests │ │ ├── CompactIntegers.cpp │ │ ├── CompactRanges.cpp │ │ ├── Integers.cpp │ │ └── Misc.cpp │ ├── ShowTypeTests.cpp │ ├── StringSerializationTests.cpp │ ├── TestMetadataTests.cpp │ ├── TestParamsTests.cpp │ ├── TestingTests.cpp │ └── VariantTests.cpp │ ├── fn │ └── CommonTests.cpp │ ├── gen │ ├── BuildTests.cpp │ ├── ChronoTests.cpp │ ├── ContainerTests │ │ ├── Common.h │ │ ├── Fixed.cpp │ │ ├── NonFixed.cpp │ │ └── Unique.cpp │ ├── CreateTests.cpp │ ├── ExecTests.cpp │ ├── MaybeTests.cpp │ ├── NumericTests.cpp │ ├── PredicateTests.cpp │ ├── SelectTests.cpp │ ├── TextTests.cpp │ ├── TransformTests.cpp │ ├── TupleTests.cpp │ └── detail │ │ ├── ExecRawTests.cpp │ │ ├── RecipeTests.cpp │ │ ├── ScaleIntegerTests.cpp │ │ └── ShrinkValueIteratorTests.cpp │ ├── main.cpp │ ├── seq │ ├── CreateTests.cpp │ ├── OperationsTests.cpp │ ├── SeqIteratorTests.cpp │ └── TransformTests.cpp │ ├── shrink │ └── ShrinkTests.cpp │ ├── shrinkable │ ├── CreateTests.cpp │ ├── OperationsTests.cpp │ └── TransformTests.cpp │ ├── state │ ├── CommandTests.cpp │ ├── CommandsTests.cpp │ ├── IntegrationTests.cpp │ ├── StateTests.cpp │ └── gen │ │ ├── CommandsTests.cpp │ │ └── ExecCommandsTests.cpp │ └── util │ ├── AppleOrange.h │ ├── ArbitraryRandom.cpp │ ├── ArbitraryRandom.h │ ├── Box.h │ ├── DestructNotifier.h │ ├── GenUtils.cpp │ ├── GenUtils.h │ ├── Generators.h │ ├── IntVec.h │ ├── Logger.h │ ├── Meta.h │ ├── MockTestListener.h │ ├── NonCopyableModel.h │ ├── Predictable.h │ ├── SeqUtils.h │ ├── Serialization.h │ ├── ShowTypeTestUtils.h │ ├── ShrinkableUtils.cpp │ ├── ShrinkableUtils.h │ ├── TemplateProps.h │ ├── ThrowOnCopy.h │ ├── TypeListMacros.h │ └── Util.h ├── modules ├── SConscript.library ├── SConscript.test ├── SConstruct ├── base │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── base │ │ │ ├── callable.h │ │ │ ├── enum_range_trait.h │ │ │ ├── fixpoint.h │ │ │ └── slice.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ ├── outpost │ │ └── base │ │ │ ├── enum_range_trait_test.cpp │ │ │ ├── fixpoint_test.cpp │ │ │ └── slice_test.cpp │ │ └── unittest │ │ ├── configurable_event_listener.cpp │ │ ├── configurable_event_listener.h │ │ ├── harness.h │ │ └── utils │ │ └── traits.h ├── comm │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── comm │ │ │ └── rmap │ │ │ ├── rmap_common.h │ │ │ ├── rmap_initiator.cpp │ │ │ ├── rmap_initiator.h │ │ │ ├── rmap_node.cpp │ │ │ ├── rmap_node.h │ │ │ ├── rmap_options.h │ │ │ ├── rmap_packet.cpp │ │ │ ├── rmap_packet.h │ │ │ ├── rmap_result.h │ │ │ ├── rmap_status.cpp │ │ │ ├── rmap_status.h │ │ │ ├── rmap_transaction.cpp │ │ │ └── rmap_transaction.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ └── outpost │ │ └── comm │ │ └── rmap_test.cpp ├── compression │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── compression │ │ │ ├── data_aggregator.cpp │ │ │ ├── data_aggregator.h │ │ │ ├── data_block.cpp │ │ │ ├── data_block.h │ │ │ ├── data_block_sender.cpp │ │ │ ├── data_block_sender.h │ │ │ ├── data_processor_thread.cpp │ │ │ ├── data_processor_thread.h │ │ │ ├── legall_wavelet.cpp │ │ │ ├── legall_wavelet.h │ │ │ ├── nls_encoder.cpp │ │ │ └── nls_encoder.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ └── outpost │ │ └── compression │ │ ├── coding_test.cpp │ │ ├── data_aggregation_test.cpp │ │ ├── data_block_test.cpp │ │ ├── data_processor_thread_test.cpp │ │ ├── nls_regression_test.cpp │ │ ├── regression_data.h │ │ └── transform_test.cpp ├── hal │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── hal │ │ │ ├── can_bus.h │ │ │ ├── datagram_transport.cpp │ │ │ ├── datagram_transport.h │ │ │ ├── file_system.cpp │ │ │ ├── file_system.h │ │ │ ├── gpio.h │ │ │ ├── protocol_dispatcher.h │ │ │ ├── protocol_dispatcher_impl.h │ │ │ ├── protocol_dispatcher_interface.h │ │ │ ├── protocol_dispatcher_thread.cpp │ │ │ ├── protocol_dispatcher_thread.h │ │ │ ├── receiver_interface.h │ │ │ ├── register.h │ │ │ ├── register_impl.h │ │ │ ├── serial.cpp │ │ │ ├── serial.h │ │ │ ├── space_wire_multi_protocol_handler.h │ │ │ ├── space_wire_multi_protocol_handler_impl.h │ │ │ ├── spacewire.cpp │ │ │ ├── spacewire.h │ │ │ ├── spi.h │ │ │ ├── timecode.h │ │ │ ├── timecode_dispatcher.h │ │ │ ├── timecode_provider.h │ │ │ └── watchdog.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ ├── outpost │ │ └── hal │ │ │ ├── can_stub_test.cpp │ │ │ ├── datagram_transport_test.cpp │ │ │ ├── dispatcher_test.cpp │ │ │ ├── file_system_stub_test.cpp │ │ │ ├── register_test.cpp │ │ │ ├── space_wire_multi_protocol_handler_test.cpp │ │ │ ├── spacewrite_stub_test.cpp │ │ │ └── timecode_dispatcher_test.cpp │ │ └── unittest │ │ └── hal │ │ ├── can_bus_stub.cpp │ │ ├── can_bus_stub.h │ │ ├── datagram_transport_stub.h │ │ ├── file_system_stub.cpp │ │ ├── file_system_stub.h │ │ ├── serial_stub.cpp │ │ ├── serial_stub.h │ │ ├── spacewire_stub.cpp │ │ ├── spacewire_stub.h │ │ ├── spi_stub.cpp │ │ ├── spi_stub.h │ │ ├── watchdog_stub.cpp │ │ └── watchdog_stub.h ├── l3test │ ├── Makefile │ ├── doc │ │ ├── Makefile │ │ ├── content.rst │ │ └── image_sources │ │ │ ├── unittest_lua_tc.raw.svg │ │ │ └── unittest_lua_tm.raw.svg │ ├── ext │ │ ├── SConscript │ │ ├── lua-5.3.4 │ │ │ ├── Makefile │ │ │ ├── README │ │ │ ├── doc │ │ │ │ ├── contents.html │ │ │ │ ├── index.css │ │ │ │ ├── logo.gif │ │ │ │ ├── lua.1 │ │ │ │ ├── lua.css │ │ │ │ ├── luac.1 │ │ │ │ ├── manual.css │ │ │ │ ├── manual.html │ │ │ │ ├── osi-certified-72x60.png │ │ │ │ └── readme.html │ │ │ └── src │ │ │ │ ├── Makefile │ │ │ │ ├── lapi.c │ │ │ │ ├── lapi.h │ │ │ │ ├── lauxlib.c │ │ │ │ ├── lauxlib.h │ │ │ │ ├── lbaselib.c │ │ │ │ ├── lbitlib.c │ │ │ │ ├── lcode.c │ │ │ │ ├── lcode.h │ │ │ │ ├── lcorolib.c │ │ │ │ ├── lctype.c │ │ │ │ ├── lctype.h │ │ │ │ ├── ldblib.c │ │ │ │ ├── ldebug.c │ │ │ │ ├── ldebug.h │ │ │ │ ├── ldo.c │ │ │ │ ├── ldo.h │ │ │ │ ├── ldump.c │ │ │ │ ├── lfunc.c │ │ │ │ ├── lfunc.h │ │ │ │ ├── lgc.c │ │ │ │ ├── lgc.h │ │ │ │ ├── linit.c │ │ │ │ ├── liolib.c │ │ │ │ ├── llex.c │ │ │ │ ├── llex.h │ │ │ │ ├── llimits.h │ │ │ │ ├── lmathlib.c │ │ │ │ ├── lmem.c │ │ │ │ ├── lmem.h │ │ │ │ ├── loadlib.c │ │ │ │ ├── lobject.c │ │ │ │ ├── lobject.h │ │ │ │ ├── lopcodes.c │ │ │ │ ├── lopcodes.h │ │ │ │ ├── loslib.c │ │ │ │ ├── lparser.c │ │ │ │ ├── lparser.h │ │ │ │ ├── lprefix.h │ │ │ │ ├── lstate.c │ │ │ │ ├── lstate.h │ │ │ │ ├── lstring.c │ │ │ │ ├── lstring.h │ │ │ │ ├── lstrlib.c │ │ │ │ ├── ltable.c │ │ │ │ ├── ltable.h │ │ │ │ ├── ltablib.c │ │ │ │ ├── ltm.c │ │ │ │ ├── ltm.h │ │ │ │ ├── lua.c │ │ │ │ ├── lua.h │ │ │ │ ├── lua.hpp │ │ │ │ ├── luac.c │ │ │ │ ├── luaconf.h │ │ │ │ ├── lualib.h │ │ │ │ ├── lundump.c │ │ │ │ ├── lundump.h │ │ │ │ ├── lutf8lib.c │ │ │ │ ├── lvm.c │ │ │ │ ├── lvm.h │ │ │ │ ├── lzio.c │ │ │ │ └── lzio.h │ │ ├── luassert │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── assert.lua │ │ │ ├── assertions.lua │ │ │ ├── compatibility.lua │ │ │ ├── formatters │ │ │ │ ├── binarystring.lua │ │ │ │ └── init.lua │ │ │ ├── init.lua │ │ │ ├── languages │ │ │ │ ├── ar.lua │ │ │ │ ├── de.lua │ │ │ │ ├── en.lua │ │ │ │ ├── fr.lua │ │ │ │ ├── ja.lua │ │ │ │ ├── nl.lua │ │ │ │ ├── ru.lua │ │ │ │ ├── ua.lua │ │ │ │ └── zh.lua │ │ │ ├── luassert-1.7.9-0.rockspec │ │ │ ├── match.lua │ │ │ ├── matchers │ │ │ │ ├── composite.lua │ │ │ │ ├── core.lua │ │ │ │ └── init.lua │ │ │ ├── mock.lua │ │ │ ├── modifiers.lua │ │ │ ├── namespaces.lua │ │ │ ├── spec │ │ │ │ ├── assertions_spec.lua │ │ │ │ ├── formatters_spec.lua │ │ │ │ ├── matchers_spec.lua │ │ │ │ ├── mocks_spec.lua │ │ │ │ ├── output_spec.lua │ │ │ │ ├── spies_spec.lua │ │ │ │ ├── state_spec.lua │ │ │ │ └── stub_spec.lua │ │ │ ├── spy.lua │ │ │ ├── state.lua │ │ │ ├── stub.lua │ │ │ └── util.lua │ │ └── say │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── CONTRIBUTING.md │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ ├── init.lua │ │ │ ├── say-1.3-1.rockspec │ │ │ └── spec │ │ │ └── say_spec.lua │ ├── lua │ │ ├── modules │ │ │ ├── SConstruct │ │ │ ├── bitstream │ │ │ │ ├── bitstream.cpp │ │ │ │ └── bitstream.h │ │ │ ├── cobs │ │ │ │ ├── cobs.cpp │ │ │ │ └── cobs.h │ │ │ ├── crc16 │ │ │ │ ├── crc16.cpp │ │ │ │ └── crc16.h │ │ │ └── l3test │ │ │ │ ├── channel.cpp │ │ │ │ ├── channel.h │ │ │ │ ├── l3test.cpp │ │ │ │ └── l3test.h │ │ ├── spec │ │ │ ├── README.txt │ │ │ ├── bitstream_spec.lua │ │ │ ├── cobs_spec.lua │ │ │ ├── crc16_spec.lua │ │ │ ├── l3test_spec.lua │ │ │ └── packetgenerator.generator_spec.lua │ │ └── src │ │ │ ├── inspect.lua │ │ │ ├── packetgenerator │ │ │ ├── generator.lua │ │ │ └── init.lua │ │ │ └── time.lua │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ ├── l3test │ │ │ └── script │ │ │ │ ├── channel.cpp │ │ │ │ ├── channel.h │ │ │ │ ├── engine.cpp │ │ │ │ └── engine.h │ │ └── lua │ │ │ ├── exception.h │ │ │ └── stackdump.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ ├── outpost │ │ └── l3test │ │ │ ├── channel_test.cpp │ │ │ └── engine_test.cpp │ │ └── unittest │ │ └── l3test │ │ ├── lua_path.cpp │ │ └── lua_path.h ├── module.default.mk ├── parameter │ ├── Makefile │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ ├── parameter.h │ │ │ └── parameter │ │ │ ├── operation_result.h │ │ │ ├── parameter.cpp │ │ │ ├── parameter.h │ │ │ ├── parameter_impl.h │ │ │ ├── parameter_iterator.h │ │ │ ├── parameter_iterator_impl.h │ │ │ ├── parameter_store.cpp │ │ │ ├── parameter_store.h │ │ │ ├── parameter_store_impl.h │ │ │ └── type.h │ └── test │ │ ├── SConscript │ │ ├── main.cpp │ │ └── outpost │ │ └── parameter │ │ ├── parameter_store_test.cpp │ │ ├── parameter_test.cpp │ │ └── type_test.cpp ├── rtos │ ├── Makefile │ ├── arch │ │ ├── freertos │ │ │ └── outpost │ │ │ │ ├── rtos.h │ │ │ │ └── rtos │ │ │ │ ├── barrier.cpp │ │ │ │ ├── barrier.h │ │ │ │ ├── clock.cpp │ │ │ │ ├── clock.h │ │ │ │ ├── failure_handler.cpp │ │ │ │ ├── mutex.cpp │ │ │ │ ├── mutex.h │ │ │ │ ├── periodic_task_manager.cpp │ │ │ │ ├── periodic_task_manager.h │ │ │ │ ├── queue.h │ │ │ │ ├── queue_impl.h │ │ │ │ ├── semaphore.cpp │ │ │ │ ├── semaphore.h │ │ │ │ ├── thread.cpp │ │ │ │ ├── thread.h │ │ │ │ ├── thread_priorities.h │ │ │ │ ├── timer.cpp │ │ │ │ ├── timer.h │ │ │ │ └── traits.h │ │ ├── none │ │ │ └── outpost │ │ │ │ ├── rtos.h │ │ │ │ └── rtos │ │ │ │ ├── barrier.h │ │ │ │ ├── clock.cpp │ │ │ │ ├── clock.h │ │ │ │ ├── failure_handler.cpp │ │ │ │ ├── mutex.cpp │ │ │ │ ├── mutex.h │ │ │ │ ├── periodic_task_manager.cpp │ │ │ │ ├── periodic_task_manager.h │ │ │ │ ├── queue.h │ │ │ │ ├── queue_impl.h │ │ │ │ ├── semaphore.cpp │ │ │ │ ├── semaphore.h │ │ │ │ ├── thread.cpp │ │ │ │ ├── thread.h │ │ │ │ ├── timer.cpp │ │ │ │ └── timer.h │ │ ├── posix │ │ │ └── outpost │ │ │ │ ├── rtos.h │ │ │ │ └── rtos │ │ │ │ ├── barrier.cpp │ │ │ │ ├── barrier.h │ │ │ │ ├── clock.cpp │ │ │ │ ├── clock.h │ │ │ │ ├── failure_handler.cpp │ │ │ │ ├── internal │ │ │ │ ├── time.cpp │ │ │ │ └── time.h │ │ │ │ ├── mutex.cpp │ │ │ │ ├── mutex.h │ │ │ │ ├── periodic_task_manager.cpp │ │ │ │ ├── periodic_task_manager.h │ │ │ │ ├── queue.h │ │ │ │ ├── queue_impl.h │ │ │ │ ├── semaphore.cpp │ │ │ │ ├── semaphore.h │ │ │ │ ├── thread.cpp │ │ │ │ ├── thread.h │ │ │ │ ├── timer.cpp │ │ │ │ └── timer.h │ │ └── rtems │ │ │ └── outpost │ │ │ ├── rtos.h │ │ │ └── rtos │ │ │ ├── barrier.cpp │ │ │ ├── barrier.h │ │ │ ├── clock.cpp │ │ │ ├── clock.h │ │ │ ├── failure_handler.cpp │ │ │ ├── mutex.cpp │ │ │ ├── mutex.h │ │ │ ├── periodic_task_manager.cpp │ │ │ ├── periodic_task_manager.h │ │ │ ├── queue.h │ │ │ ├── queue_impl.h │ │ │ ├── rtems │ │ │ └── interval.h │ │ │ ├── semaphore.cpp │ │ │ ├── semaphore.h │ │ │ ├── thread.cpp │ │ │ ├── thread.h │ │ │ ├── timer.cpp │ │ │ └── timer.h │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── it │ │ ├── README.md │ │ ├── SConscript │ │ ├── barrier │ │ │ ├── SConstruct │ │ │ └── main.cpp │ │ ├── freertos │ │ │ ├── SConstruct │ │ │ ├── main.cpp │ │ │ ├── openocd.cfg │ │ │ └── project.cfg │ │ ├── none_or32 │ │ │ ├── SConstruct │ │ │ └── main.cpp │ │ ├── posix │ │ │ ├── SConstruct │ │ │ └── main.cpp │ │ ├── reference │ │ │ ├── consumer.cpp │ │ │ ├── consumer.h │ │ │ ├── producer.cpp │ │ │ └── producer.h │ │ └── rtems │ │ │ ├── Makefile │ │ │ ├── SConstruct │ │ │ ├── main.cpp │ │ │ ├── program.sh │ │ │ └── system.h │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── rtos │ │ │ ├── checkpoint.cpp │ │ │ ├── checkpoint.h │ │ │ ├── failure_handler.h │ │ │ ├── failure_handler_common.cpp │ │ │ ├── locking_policy.h │ │ │ └── mutex_guard.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ └── main.cpp ├── sip │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── sip │ │ │ ├── coordinator │ │ │ ├── coordinator.cpp │ │ │ ├── coordinator.h │ │ │ ├── coordinator_packet_receiver.cpp │ │ │ └── coordinator_packet_receiver.h │ │ │ ├── packet │ │ │ ├── packet_reader.cpp │ │ │ ├── packet_reader.h │ │ │ ├── packet_writer.cpp │ │ │ └── packet_writer.h │ │ │ ├── packet_coder │ │ │ ├── packet_coder.h │ │ │ ├── packet_coder_hdlc.cpp │ │ │ └── packet_coder_hdlc.h │ │ │ ├── packet_transport │ │ │ ├── packet_transport.h │ │ │ ├── packet_transport_serial.cpp │ │ │ └── packet_transport_serial.h │ │ │ ├── sip.h │ │ │ └── worker │ │ │ ├── worker.cpp │ │ │ └── worker.h │ └── test │ │ ├── SConscript │ │ ├── main.cpp │ │ └── outpost │ │ └── sip │ │ ├── coordinator │ │ ├── test_coordinator.cpp │ │ └── test_coordinator_packet_receiver.cpp │ │ ├── packet │ │ ├── test_packet_reader.cpp │ │ └── test_packet_writer.cpp │ │ ├── packet_coder │ │ └── test_packet_coder_hdlc.cpp │ │ ├── packet_transport │ │ └── test_packet_transport_serial.cpp │ │ └── worker │ │ └── test_worker.cpp ├── smpc │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ ├── smpc.h │ │ │ └── smpc │ │ │ ├── subscriber.h │ │ │ ├── subscription.cpp │ │ │ ├── subscription.h │ │ │ ├── subscription_raw.cpp │ │ │ ├── subscription_raw.h │ │ │ ├── topic.cpp │ │ │ ├── topic.h │ │ │ ├── topic_raw.cpp │ │ │ └── topic_raw.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ ├── outpost │ │ └── smpc │ │ │ ├── communication_test.cpp │ │ │ ├── subscription_raw_test.cpp │ │ │ ├── subscription_test.cpp │ │ │ ├── subscription_virtual_class_test.cpp │ │ │ ├── testing_topic.cpp │ │ │ ├── topic_logger_test.cpp │ │ │ └── topic_type_test.cpp │ │ └── unittest │ │ └── smpc │ │ ├── testing_subscription.h │ │ ├── testing_subscription_raw.h │ │ ├── topic_logger.h │ │ └── topic_logger_impl.h ├── support │ ├── Makefile │ ├── default │ │ └── outpost │ │ │ └── parameter │ │ │ └── support.h │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ └── support │ │ │ ├── heartbeat.cpp │ │ │ ├── heartbeat.h │ │ │ ├── heartbeat_limiter.cpp │ │ │ └── heartbeat_limiter.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ └── outpost │ │ └── support │ │ └── heartbeat_limiter_test.cpp ├── swb │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ ├── swb.h │ │ │ └── swb │ │ │ ├── bus_channel.h │ │ │ ├── bus_channel_impl.h │ │ │ ├── bus_distributor.h │ │ │ ├── bus_distributor_impl.h │ │ │ ├── bus_handler_thread.h │ │ │ ├── bus_handler_thread_impl.h │ │ │ ├── bus_subscription.h │ │ │ ├── default_message_filter.h │ │ │ ├── message_handler.h │ │ │ ├── software_bus.h │ │ │ ├── software_bus_impl.h │ │ │ └── types.h │ └── test │ │ ├── SConscript │ │ ├── main.cpp │ │ ├── outpost │ │ └── swb │ │ │ ├── bus_channel_test.cpp │ │ │ ├── bus_handler_thread_test.cpp │ │ │ ├── bus_subscription_test.cpp │ │ │ ├── filtered_software_bus.cpp │ │ │ └── software_bus_test.cpp │ │ └── unittest │ │ └── swb │ │ ├── testing_software_bus.cpp │ │ └── testing_software_bus.h ├── time │ ├── Makefile │ ├── doc │ │ └── doxygen │ │ │ ├── doxyfile │ │ │ └── doxyfile-internal │ ├── module.lb │ ├── src │ │ ├── SConscript │ │ └── outpost │ │ │ ├── time.h │ │ │ └── time │ │ │ ├── clock.h │ │ │ ├── date.cpp │ │ │ ├── date.h │ │ │ ├── duration.h │ │ │ ├── quota.cpp │ │ │ ├── quota.h │ │ │ ├── quota_impl.h │ │ │ ├── time_epoch.cpp │ │ │ ├── time_epoch.h │ │ │ ├── time_epoch_impl.h │ │ │ ├── time_point.h │ │ │ ├── timeout.cpp │ │ │ └── timeout.h │ └── test │ │ ├── SConscript │ │ ├── SConstruct │ │ ├── main.cpp │ │ ├── outpost │ │ └── time │ │ │ ├── date_test.cpp │ │ │ ├── date_utils_test.cpp │ │ │ ├── duration_test.cpp │ │ │ ├── quota_test.cpp │ │ │ ├── time_epoch_test.cpp │ │ │ ├── time_point_test.cpp │ │ │ └── timeout_test.cpp │ │ └── unittest │ │ └── time │ │ ├── printer.cpp │ │ ├── printer.h │ │ ├── testing_clock.cpp │ │ └── testing_clock.h └── utils │ ├── Makefile │ ├── doc │ └── doxygen │ │ ├── doxyfile │ │ └── doxyfile-internal │ ├── ext │ ├── README.md │ ├── SConscript │ ├── googletest-1.8.1-fused │ │ ├── gmock-gtest-all.cc │ │ ├── gmock │ │ │ └── gmock.h │ │ └── gtest │ │ │ └── gtest.h │ └── rapidcheck │ │ ├── .clang-format │ │ ├── .dir-locals.el │ │ ├── .gitignore │ │ ├── .gitmodules │ │ ├── .travis.yml │ │ ├── CMakeLists.txt │ │ ├── LICENSE.md │ │ ├── README.md │ │ ├── appveyor.yml │ │ ├── doc │ │ ├── Gen.md │ │ ├── Seq.md │ │ ├── Shrinkable.md │ │ ├── assertions.md │ │ ├── boost.md │ │ ├── boost_test.md │ │ ├── configuration.md │ │ ├── debugging.md │ │ ├── displaying.md │ │ ├── distribution.md │ │ ├── generators.md │ │ ├── generators_ref.md │ │ ├── gmock.md │ │ ├── gtest.md │ │ ├── properties.md │ │ ├── state.md │ │ ├── state_ref.md │ │ └── user_guide.md │ │ ├── examples │ │ ├── CMakeLists.txt │ │ ├── boost_test │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ ├── classify │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ ├── counter │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ ├── database │ │ │ ├── CMakeLists.txt │ │ │ ├── Database.cpp │ │ │ ├── Database.h │ │ │ ├── DatabaseConnection.cpp │ │ │ ├── DatabaseConnection.h │ │ │ ├── Generators.h │ │ │ ├── User.cpp │ │ │ ├── User.h │ │ │ └── main.cpp │ │ ├── gtest │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ └── mapparser │ │ │ ├── CMakeLists.txt │ │ │ ├── MapParser.cpp │ │ │ ├── MapParser.h │ │ │ └── main.cpp │ │ ├── ext │ │ ├── CMakeLists.txt │ │ └── get_boost.sh │ │ ├── extras │ │ ├── CMakeLists.txt │ │ ├── boost │ │ │ ├── CMakeLists.txt │ │ │ ├── include │ │ │ │ └── rapidcheck │ │ │ │ │ ├── boost.h │ │ │ │ │ └── gen │ │ │ │ │ └── boost │ │ │ │ │ ├── Optional.h │ │ │ │ │ └── Optional.hpp │ │ │ └── test │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── OptionalTests.cpp │ │ │ │ └── main.cpp │ │ ├── boost_test │ │ │ ├── CMakeLists.txt │ │ │ └── include │ │ │ │ └── rapidcheck │ │ │ │ └── boost_test.h │ │ ├── catch │ │ │ ├── CMakeLists.txt │ │ │ └── include │ │ │ │ └── rapidcheck │ │ │ │ └── catch.h │ │ ├── gmock │ │ │ ├── CMakeLists.txt │ │ │ ├── include │ │ │ │ └── rapidcheck │ │ │ │ │ └── gmock.h │ │ │ └── test │ │ │ │ ├── CMakeLists.txt │ │ │ │ └── main.cpp │ │ └── gtest │ │ │ ├── CMakeLists.txt │ │ │ └── include │ │ │ └── rapidcheck │ │ │ └── gtest.h │ │ ├── include │ │ ├── rapidcheck.h │ │ └── rapidcheck │ │ │ ├── Assertions.h │ │ │ ├── Assertions.hpp │ │ │ ├── BeforeMinimalTestCase.h │ │ │ ├── Check.h │ │ │ ├── Check.hpp │ │ │ ├── Classify.h │ │ │ ├── Classify.hpp │ │ │ ├── Gen.h │ │ │ ├── Gen.hpp │ │ │ ├── GenerationFailure.h │ │ │ ├── Log.h │ │ │ ├── Log.hpp │ │ │ ├── Maybe.h │ │ │ ├── Maybe.hpp │ │ │ ├── Nothing.h │ │ │ ├── Random.h │ │ │ ├── Random.hpp │ │ │ ├── Seq.h │ │ │ ├── Seq.hpp │ │ │ ├── Show.h │ │ │ ├── Show.hpp │ │ │ ├── Shrinkable.h │ │ │ ├── Shrinkable.hpp │ │ │ ├── Traits.h │ │ │ ├── detail │ │ │ ├── AlignedUnion.h │ │ │ ├── Any.h │ │ │ ├── Any.hpp │ │ │ ├── ApplyTuple.h │ │ │ ├── BitStream.h │ │ │ ├── BitStream.hpp │ │ │ ├── Capture.h │ │ │ ├── Configuration.h │ │ │ ├── ExecFixture.h │ │ │ ├── FrequencyMap.h │ │ │ ├── FunctionTraits.h │ │ │ ├── ImplicitParam.h │ │ │ ├── ImplicitParam.hpp │ │ │ ├── IntSequence.h │ │ │ ├── Platform.h │ │ │ ├── Property.h │ │ │ ├── Property.hpp │ │ │ ├── PropertyContext.h │ │ │ ├── Results.h │ │ │ ├── Results.hpp │ │ │ ├── Serialization.h │ │ │ ├── Serialization.hpp │ │ │ ├── ShowType.h │ │ │ ├── ShowType.hpp │ │ │ ├── TestListener.h │ │ │ ├── TestListenerAdapter.h │ │ │ ├── TestMetadata.h │ │ │ ├── TestParams.h │ │ │ ├── Traits.h │ │ │ ├── TypeList.h │ │ │ ├── Utility.h │ │ │ ├── Variant.h │ │ │ └── Variant.hpp │ │ │ ├── fn │ │ │ ├── Common.h │ │ │ └── Common.hpp │ │ │ ├── gen │ │ │ ├── Arbitrary.h │ │ │ ├── Arbitrary.hpp │ │ │ ├── Build.h │ │ │ ├── Build.hpp │ │ │ ├── Chrono.h │ │ │ ├── Chrono.hpp │ │ │ ├── Container.h │ │ │ ├── Container.hpp │ │ │ ├── Create.h │ │ │ ├── Create.hpp │ │ │ ├── Exec.h │ │ │ ├── Exec.hpp │ │ │ ├── Maybe.h │ │ │ ├── Maybe.hpp │ │ │ ├── Numeric.h │ │ │ ├── Numeric.hpp │ │ │ ├── Predicate.h │ │ │ ├── Predicate.hpp │ │ │ ├── Select.h │ │ │ ├── Select.hpp │ │ │ ├── Text.h │ │ │ ├── Text.hpp │ │ │ ├── Transform.h │ │ │ ├── Transform.hpp │ │ │ ├── Tuple.h │ │ │ ├── Tuple.hpp │ │ │ └── detail │ │ │ │ ├── ExecHandler.h │ │ │ │ ├── ExecRaw.h │ │ │ │ ├── ExecRaw.hpp │ │ │ │ ├── GenerationHandler.h │ │ │ │ ├── Recipe.h │ │ │ │ ├── ScaleInteger.h │ │ │ │ ├── ShrinkValueIterator.h │ │ │ │ └── ShrinkValueIterator.hpp │ │ │ ├── seq │ │ │ ├── Create.h │ │ │ ├── Create.hpp │ │ │ ├── Operations.h │ │ │ ├── Operations.hpp │ │ │ ├── SeqIterator.h │ │ │ ├── SeqIterator.hpp │ │ │ ├── Transform.h │ │ │ └── Transform.hpp │ │ │ ├── shrink │ │ │ ├── Shrink.h │ │ │ └── Shrink.hpp │ │ │ ├── shrinkable │ │ │ ├── Create.h │ │ │ ├── Create.hpp │ │ │ ├── Operations.h │ │ │ ├── Operations.hpp │ │ │ ├── Transform.h │ │ │ └── Transform.hpp │ │ │ ├── state.h │ │ │ └── state │ │ │ ├── Command.h │ │ │ ├── Command.hpp │ │ │ ├── Commands.h │ │ │ ├── Commands.hpp │ │ │ ├── State.h │ │ │ ├── State.hpp │ │ │ └── gen │ │ │ ├── Commands.h │ │ │ ├── Commands.hpp │ │ │ ├── ExecCommands.h │ │ │ └── ExecCommands.hpp │ │ ├── src │ │ ├── BeforeMinimalTestCase.cpp │ │ ├── Check.cpp │ │ ├── Classify.cpp │ │ ├── GenerationFailure.cpp │ │ ├── Log.cpp │ │ ├── Random.cpp │ │ ├── Show.cpp │ │ ├── detail │ │ │ ├── Any.cpp │ │ │ ├── Assertions.cpp │ │ │ ├── Base64.cpp │ │ │ ├── Base64.h │ │ │ ├── Configuration.cpp │ │ │ ├── DefaultTestListener.cpp │ │ │ ├── DefaultTestListener.h │ │ │ ├── FrequencyMap.cpp │ │ │ ├── ImplicitParam.cpp │ │ │ ├── LogTestListener.cpp │ │ │ ├── LogTestListener.h │ │ │ ├── MapParser.cpp │ │ │ ├── MapParser.h │ │ │ ├── MulticastTestListener.cpp │ │ │ ├── MulticastTestListener.h │ │ │ ├── ParseException.cpp │ │ │ ├── ParseException.h │ │ │ ├── Platform.cpp │ │ │ ├── Property.cpp │ │ │ ├── PropertyContext.cpp │ │ │ ├── ReproduceListener.cpp │ │ │ ├── ReproduceListener.h │ │ │ ├── Results.cpp │ │ │ ├── Serialization.cpp │ │ │ ├── StringSerialization.cpp │ │ │ ├── StringSerialization.h │ │ │ ├── TestMetadata.cpp │ │ │ ├── TestParams.cpp │ │ │ ├── Testing.cpp │ │ │ └── Testing.h │ │ └── gen │ │ │ ├── Numeric.cpp │ │ │ ├── Text.cpp │ │ │ └── detail │ │ │ ├── ExecHandler.cpp │ │ │ ├── GenerationHandler.cpp │ │ │ ├── Recipe.cpp │ │ │ └── ScaleInteger.cpp │ │ └── test │ │ ├── AssertionsTests.cpp │ │ ├── CMakeLists.txt │ │ ├── CheckTests.cpp │ │ ├── ClassifyTests.cpp │ │ ├── GenTests.cpp │ │ ├── LogTests.cpp │ │ ├── MaybeTests.cpp │ │ ├── RandomTests.cpp │ │ ├── SeqTests.cpp │ │ ├── ShowTests.cpp │ │ ├── ShrinkableTests.cpp │ │ ├── detail │ │ ├── AnyTests.cpp │ │ ├── ApplyTupleTests.cpp │ │ ├── Base64Tests.cpp │ │ ├── BitStreamTests.cpp │ │ ├── CaptureTests.cpp │ │ ├── ConfigurationTests.cpp │ │ ├── DefaultTestListenerTests.cpp │ │ ├── FrequencyMapTests.cpp │ │ ├── ImplicitParamTests.cpp │ │ ├── LogTestListenerTests.cpp │ │ ├── MapParserTests.cpp │ │ ├── MulticastTestListenerTests.cpp │ │ ├── PropertyTests.cpp │ │ ├── ReproduceListenerTests.cpp │ │ ├── ResultsTests.cpp │ │ ├── SerializationTests │ │ │ ├── CompactIntegers.cpp │ │ │ ├── CompactRanges.cpp │ │ │ ├── Integers.cpp │ │ │ └── Misc.cpp │ │ ├── ShowTypeTests.cpp │ │ ├── StringSerializationTests.cpp │ │ ├── TestMetadataTests.cpp │ │ ├── TestParamsTests.cpp │ │ ├── TestingTests.cpp │ │ └── VariantTests.cpp │ │ ├── fn │ │ └── CommonTests.cpp │ │ ├── gen │ │ ├── BuildTests.cpp │ │ ├── ChronoTests.cpp │ │ ├── ContainerTests │ │ │ ├── Common.h │ │ │ ├── Fixed.cpp │ │ │ ├── NonFixed.cpp │ │ │ └── Unique.cpp │ │ ├── CreateTests.cpp │ │ ├── ExecTests.cpp │ │ ├── MaybeTests.cpp │ │ ├── NumericTests.cpp │ │ ├── PredicateTests.cpp │ │ ├── SelectTests.cpp │ │ ├── TextTests.cpp │ │ ├── TransformTests.cpp │ │ ├── TupleTests.cpp │ │ └── detail │ │ │ ├── ExecRawTests.cpp │ │ │ ├── RecipeTests.cpp │ │ │ ├── ScaleIntegerTests.cpp │ │ │ └── ShrinkValueIteratorTests.cpp │ │ ├── main.cpp │ │ ├── seq │ │ ├── CreateTests.cpp │ │ ├── OperationsTests.cpp │ │ ├── SeqIteratorTests.cpp │ │ └── TransformTests.cpp │ │ ├── shrink │ │ └── ShrinkTests.cpp │ │ ├── shrinkable │ │ ├── CreateTests.cpp │ │ ├── OperationsTests.cpp │ │ └── TransformTests.cpp │ │ ├── state │ │ ├── CommandTests.cpp │ │ ├── CommandsTests.cpp │ │ ├── IntegrationTests.cpp │ │ ├── StateTests.cpp │ │ └── gen │ │ │ ├── CommandsTests.cpp │ │ │ └── ExecCommandsTests.cpp │ │ └── util │ │ ├── AppleOrange.h │ │ ├── ArbitraryRandom.cpp │ │ ├── ArbitraryRandom.h │ │ ├── Box.h │ │ ├── DestructNotifier.h │ │ ├── GenUtils.cpp │ │ ├── GenUtils.h │ │ ├── Generators.h │ │ ├── IntVec.h │ │ ├── Logger.h │ │ ├── Meta.h │ │ ├── MockTestListener.h │ │ ├── NonCopyableModel.h │ │ ├── Predictable.h │ │ ├── SeqUtils.h │ │ ├── Serialization.h │ │ ├── ShowTypeTestUtils.h │ │ ├── ShrinkableUtils.cpp │ │ ├── ShrinkableUtils.h │ │ ├── TemplateProps.h │ │ ├── ThrowOnCopy.h │ │ ├── TypeListMacros.h │ │ └── Util.h │ ├── module.lb │ ├── src │ ├── SConscript │ └── outpost │ │ ├── utils.h │ │ └── utils │ │ ├── README.md │ │ ├── base_member_pair.h │ │ ├── coding │ │ ├── cobs.h │ │ ├── cobs_impl.h │ │ ├── coding.h │ │ ├── crc.h │ │ ├── crc16.cpp │ │ ├── crc16.h │ │ ├── crc32.cpp │ │ ├── crc32.h │ │ ├── crc8.cpp │ │ ├── crc8.h │ │ ├── hdlc.cpp │ │ ├── hdlc.h │ │ ├── nand_bch_compiletime.h │ │ ├── nand_bch_compiletime_impl.h │ │ ├── nand_bch_interface.cpp │ │ ├── nand_bch_interface.h │ │ ├── nand_bch_runtime.h │ │ └── nand_bch_runtime_impl.h │ │ ├── communicator.h │ │ ├── container │ │ ├── byte_array_ring_buffer.h │ │ ├── circular_singly_linked_list.h │ │ ├── circular_singly_linked_list_impl.h │ │ ├── container.h │ │ ├── deque.h │ │ ├── deque_impl.h │ │ ├── fixed_ordered_map.h │ │ ├── fixed_ordered_map_impl.h │ │ ├── fixed_size_array.h │ │ ├── implicit_list.h │ │ ├── list.h │ │ ├── list_impl.h │ │ ├── member_function_store.h │ │ ├── reference_queue.h │ │ ├── shared_buffer.cpp │ │ ├── shared_buffer.dox │ │ ├── shared_buffer.h │ │ ├── shared_object_pool.h │ │ └── shared_ring_buffer.h │ │ ├── error_code.h │ │ ├── functor.h │ │ ├── iterator.h │ │ ├── iterator_impl.h │ │ ├── limits.h │ │ ├── log2.h │ │ ├── meta.h │ │ ├── minmax.h │ │ ├── operation_result.h │ │ ├── pow.h │ │ └── storage │ │ ├── big_endian_int.h │ │ ├── bit_access.h │ │ ├── bit_access_impl.h │ │ ├── bitfield.h │ │ ├── bitfield_impl.h │ │ ├── bitorder.h │ │ ├── bitstream.h │ │ ├── output_stream.h │ │ ├── serializable_object.cpp │ │ ├── serializable_object.h │ │ ├── serialize.h │ │ ├── serialize_little_endian.h │ │ ├── serialize_little_endian_traits.h │ │ ├── serialize_storage_traits.h │ │ ├── serialize_traits.h │ │ ├── storage.h │ │ ├── variable_width_enum.h │ │ └── variable_width_integer.h │ ├── test │ ├── SConscript │ ├── SConstruct │ ├── main.cpp │ ├── outpost │ │ └── utils │ │ │ ├── coding │ │ │ ├── bchCTTest.cpp │ │ │ ├── bchRTTest.cpp │ │ │ ├── cobs_generator_test.cpp │ │ │ ├── cobs_roundtrip_test.cpp │ │ │ ├── cobs_test.cpp │ │ │ ├── crc16_test.cpp │ │ │ ├── crc32_test.cpp │ │ │ ├── crc8_test.cpp │ │ │ └── hdlc_test.cpp │ │ │ ├── container │ │ │ ├── byte_array_ring_buffer_test.cpp │ │ │ ├── circular_singly_linked_list_test.cpp │ │ │ ├── deque_test.cpp │ │ │ ├── external_shared_buffer_test.cpp │ │ │ ├── fixed_ordered_map_test.cpp │ │ │ ├── fixed_size_array_test.cpp │ │ │ ├── implicit_list_test.cpp │ │ │ ├── list_test.cpp │ │ │ ├── member_function_store_test.cpp │ │ │ ├── reference_queue_test.cpp │ │ │ ├── shared_buffer_test.cpp │ │ │ └── shared_ring_buffer_test.cpp │ │ │ ├── error_code_test.cpp │ │ │ ├── functor_test.cpp │ │ │ ├── log2_test.cpp │ │ │ ├── minmax_test.cpp │ │ │ ├── pow_test.cpp │ │ │ └── storage │ │ │ ├── big_endian_int_test.cpp │ │ │ ├── bit_access_test.cpp │ │ │ ├── bitfield_little_endian_test.cpp │ │ │ ├── bitfield_test.cpp │ │ │ ├── bitorder_test.cpp │ │ │ ├── bitstream_test.cpp │ │ │ ├── deserialize_little_endian_test.cpp │ │ │ ├── deserialize_test.cpp │ │ │ ├── serialize_little_endian_test.cpp │ │ │ ├── serialize_storage_traits_test.cpp │ │ │ ├── serialize_test.cpp │ │ │ ├── variable_width_enum_test.cpp │ │ │ ├── variable_width_integer_arithmetic_test.cpp │ │ │ ├── variable_width_integer_binary_arithmetic_test.cpp │ │ │ ├── variable_width_integer_cast_test.cpp │ │ │ ├── variable_width_integer_relational_test.cpp │ │ │ └── variable_width_integer_test.cpp │ └── unittest │ │ └── utils │ │ ├── container │ │ └── reference_queue_stub.h │ │ └── storage │ │ ├── output_stream_stub.cpp │ │ └── output_stream_stub.h │ └── tools │ └── gen_crc_table.py ├── outpost.lb ├── test └── sparc_rtems │ ├── Makefile │ ├── SConstruct │ ├── main.cpp │ ├── program.sh │ └── system.h ├── tools ├── comment_converter.py ├── gtest_process_skipped.py ├── naming_checker │ ├── IdentifierParser.py │ └── ast_test.cpp └── vera++ │ ├── profiles │ └── outpost │ └── scripts │ ├── rules │ ├── DUMP.tcl │ ├── F001.tcl │ ├── F002.tcl │ ├── L001.tcl │ ├── L002.tcl │ ├── L003.tcl │ ├── L004.tcl │ ├── L005.tcl │ ├── L006.tcl │ ├── T001.tcl │ ├── T002.tcl │ ├── T003.tcl │ ├── T004.tcl │ ├── T005.tcl │ ├── T006.tcl │ ├── T007.tcl │ ├── T008.tcl │ ├── T009.tcl │ ├── T010.tcl │ ├── T011.tcl │ ├── T012.tcl │ ├── T013.tcl │ ├── T014.tcl │ ├── T015.tcl │ ├── T016.tcl │ ├── T017.tcl │ ├── T018.tcl │ └── T019.tcl │ └── transformations │ ├── move_includes.tcl │ ├── move_macros.tcl │ ├── move_namespace.tcl │ ├── to_lower.tcl │ ├── to_xml.tcl │ ├── to_xml2.tcl │ └── trim_right.tcl └── tpl └── SConstruct.in /.cppcheck-excludes: -------------------------------------------------------------------------------- 1 | *:*/outpost-core/ext/* 2 | invalidPrintfArgType_uint:*comm/rmap/rmap_initiator.cpp 3 | memsetClass:*base/slice.h:407 4 | noExplicitConstructor:*utils/iterator* 5 | functionStatic:*utils/container/list* 6 | functionConst:*utils/container/list* 7 | noExplicitConstructor:*utils/container/list* 8 | functionStatic:*utils/container/circular_singly_linked_list* 9 | noExplicitConstructor:*utils/container/circular_singly_linked_list* 10 | redundantCondition:*utils/storage/bit_access* 11 | redundantCondition:*utils/storage/bitfield* 12 | noExplicitConstructor:*utils/storage/big_endian_int.h 13 | unreadVariable:*parameter/parameter_store_test.cpp 14 | useStlAlgorithm:*utils/coding/crc8_test.cpp 15 | useStlAlgorithm:*utils/coding/crc32_test.cpp 16 | unusedFunction:* 17 | missingIncludeSystem:* 18 | unmatchedSuppression:* 19 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Project files 3 | .settings 4 | .project 5 | .cproject 6 | .pydevproject 7 | 8 | # Build tools 9 | build/ 10 | bin/ 11 | modules/*/doc/doxygen/api/* 12 | .sconsign.dblite 13 | *.pyc 14 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /CONTRIBUTORS.md: -------------------------------------------------------------------------------- 1 | 2 | Contributors 3 | ------------ 4 | 5 | 13 | 14 | * German Aerospace Center (DLR) 15 | - Fabian Greif 16 | - Jan Sommer 17 | - Benjamin Weps 18 | - Muhammad Bassam 19 | - Murat Goeksu 20 | - Jan-Gerd Mess 21 | - Norbert Toth 22 | - Olaf Maibaum 23 | - Rhea Rinaldo 24 | - Annika Ofenloch 25 | - Janosch Reinking 26 | -------------------------------------------------------------------------------- /VERSION: -------------------------------------------------------------------------------- 1 | 0.6 2 | -------------------------------------------------------------------------------- /doc/images/OUTPOST_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DLR-RY/outpost-core/de9e69903d0722decd3a6dd8f5e5d609864193ee/doc/images/OUTPOST_logo.png -------------------------------------------------------------------------------- /doc/lbuild/.gitignore: -------------------------------------------------------------------------------- 1 | dep.dot 2 | dep.png 3 | dep_test.dot 4 | dep_test.png 5 | source/ 6 | *.log 7 | -------------------------------------------------------------------------------- /doc/lbuild/project.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | ../../outpost.lb 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /ext/gsl/.clang-format: -------------------------------------------------------------------------------- 1 | ColumnLimit: 100 2 | 3 | UseTab: Never 4 | IndentWidth: 4 5 | AccessModifierOffset: -4 6 | NamespaceIndentation: Inner 7 | 8 | BreakBeforeBraces: Allman 9 | AlwaysBreakTemplateDeclarations: true 10 | BreakConstructorInitializersBeforeComma: true 11 | ConstructorInitializerAllOnOneLineOrOnePerLine: true 12 | AllowShortBlocksOnASingleLine: true 13 | AllowShortFunctionsOnASingleLine: All 14 | AllowShortIfStatementsOnASingleLine: true 15 | AllowShortLoopsOnASingleLine: true 16 | 17 | PointerAlignment: Left 18 | AlignConsecutiveAssignments: false 19 | AlignTrailingComments: true 20 | 21 | SpaceAfterCStyleCast: true 22 | -------------------------------------------------------------------------------- /ext/gsl/.gitignore: -------------------------------------------------------------------------------- 1 | CMakeFiles 2 | tests/CMakeFiles 3 | tests/Debug 4 | *.opensdf 5 | *.sdf 6 | tests/*tests.dir 7 | *.vcxproj 8 | *.vcxproj.filters 9 | *.sln 10 | *.tlog 11 | Testing/Temporary/*.* 12 | CMakeCache.txt 13 | *.suo 14 | -------------------------------------------------------------------------------- /ext/gsl/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.7) 2 | 3 | project(GSL CXX) 4 | 5 | set(GSL_HEADERS 6 | "gsl/gsl" 7 | "gsl/gsl_assert" 8 | "gsl/gsl_byte" 9 | "gsl/gsl_util" 10 | "gsl/multi_span" 11 | "gsl/span" 12 | "gsl/string_span" 13 | "gsl/gsl_algorithm" 14 | ) 15 | 16 | include_directories( 17 | ${CMAKE_CURRENT_BINARY_DIR} 18 | ) 19 | 20 | install(FILES ${GSL_HEADERS} 21 | DESTINATION include/gsl 22 | ) 23 | 24 | enable_testing() 25 | 26 | add_subdirectory(tests) 27 | -------------------------------------------------------------------------------- /ext/icecream-0.3.1/AUTHORS: -------------------------------------------------------------------------------- 1 | Renato Florentino Garcia 2 | -------------------------------------------------------------------------------- /ext/icecream-0.3.1/meson.build: -------------------------------------------------------------------------------- 1 | project( 2 | 'IceCream-tests', 3 | 'cpp', 4 | meson_version: '>= 0.40.0', 5 | license: 'MIT', 6 | ) 7 | 8 | 9 | test_cpp11 = executable( 10 | 'test_cpp11', 11 | 'test.cpp', 12 | cpp_args: '-DCPP_11', 13 | override_options: ['cpp_std=c++11'], 14 | ) 15 | test('test_cpp11', test_cpp11) 16 | 17 | 18 | test_cpp14 = executable( 19 | 'test_cpp14', 20 | 'test.cpp', 21 | cpp_args: '-DCPP_14', 22 | override_options: ['cpp_std=c++14'], 23 | ) 24 | test('test_cpp14', test_cpp14) 25 | 26 | 27 | test_cpp17 = executable( 28 | 'test_cpp17', 29 | 'test.cpp', 30 | cpp_args: '-DCPP_17', 31 | override_options: ['cpp_std=c++17'], 32 | ) 33 | test('test_cpp17', test_cpp17) 34 | -------------------------------------------------------------------------------- /ext/icecream-0.3.1/test_2.cpp: -------------------------------------------------------------------------------- 1 | // Header used to catch multiple symbol definition 2 | 3 | #include "icecream.hpp" 4 | -------------------------------------------------------------------------------- /ext/rapidcheck/.dir-locals.el: -------------------------------------------------------------------------------- 1 | ((nil . ((c-basic-offset . 2)))) 2 | -------------------------------------------------------------------------------- /ext/rapidcheck/.gitignore: -------------------------------------------------------------------------------- 1 | /build* 2 | GPATH 3 | GRTAGS 4 | GTAGS 5 | TAGS 6 | ext/gmock 7 | ext/boost -------------------------------------------------------------------------------- /ext/rapidcheck/.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "ext/catch"] 2 | path = ext/catch 3 | url = https://github.com/philsquared/Catch.git 4 | [submodule "ext/googletest"] 5 | path = ext/googletest 6 | url = https://github.com/google/googletest 7 | -------------------------------------------------------------------------------- /ext/rapidcheck/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: 1.0.{build} 2 | os: Visual Studio 2015 3 | 4 | branches: 5 | only: 6 | - master 7 | 8 | environment: 9 | matrix: 10 | - CMAKE_BUILD_TYPE: Debug 11 | ARCH: amd64 12 | - CMAKE_BUILD_TYPE: Release 13 | ARCH: amd64 14 | - CMAKE_BUILD_TYPE: Debug 15 | ARCH: x86 16 | - CMAKE_BUILD_TYPE: Release 17 | ARCH: x86 18 | 19 | install: 20 | - git submodule update --init --recursive 21 | 22 | build_script: 23 | - md build 24 | - cd build 25 | - "\"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat\" %ARCH%" 26 | - cmake -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DRC_ENABLE_TESTS=ON -DRC_ENABLE_EXAMPLES=ON -DRC_ENABLE_GTEST=ON -DRC_ENABLE_GMOCK=ON -DRC_ENABLE_BOOST=ON -DRC_ENABLE_BOOST_TEST=ON -G "NMake Makefiles" .. 27 | - nmake 28 | 29 | test_script: 30 | - ctest --output-on-failure -------------------------------------------------------------------------------- /ext/rapidcheck/doc/Gen.md: -------------------------------------------------------------------------------- 1 | `Gen` 2 | ======= 3 | _This section is incomplete._ 4 | -------------------------------------------------------------------------------- /ext/rapidcheck/doc/Seq.md: -------------------------------------------------------------------------------- 1 | `Seq` 2 | ======= 3 | _This section is incomplete._ 4 | 5 | `Seq` implements a lazy sequence (often called a "stream") of values of type `T`. It has a super simple interface for retrieving these values consisting only of the method `Maybe next()`. As can be seen, it returns a `Maybe` which is similar to `boost::optional`, Haskell's `Maybe` or other similar types that either contain a value or be empty. `next` successively returns the values in the sequence until the sequence is exhausted after which it will return an empty `Maybe` to signal that there are no more values. 6 | 7 | `Seq`s are mutable since calling `next` will modify the `Seq` by advancing it. They also have value semantics since you can copy them and pass them around like any other value. 8 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(counter) 2 | add_subdirectory(mapparser) 3 | add_subdirectory(database) 4 | add_subdirectory(classify) 5 | 6 | if (RC_ENABLE_GTEST) 7 | add_subdirectory(gtest) 8 | endif() 9 | 10 | if (RC_ENABLE_BOOST_TEST) 11 | add_subdirectory(boost_test) 12 | endif() 13 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/boost_test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(boost_test_integration main.cpp) 2 | target_link_libraries(boost_test_integration rapidcheck_boost_test boost) 3 | if (MSVC) 4 | target_compile_options(boost_test_integration PRIVATE "/EHa") 5 | else() 6 | # Boost uses auto_ptr which causes warnings on (at least) GCC 7 | target_compile_options(boost_test_integration PRIVATE "-Wno-deprecated-declarations") 8 | endif() 9 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/classify/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(classify main.cpp) 2 | target_link_libraries(classify rapidcheck) -------------------------------------------------------------------------------- /ext/rapidcheck/examples/classify/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace rc; 4 | 5 | enum class Gender { Male, Female }; 6 | 7 | std::ostream &operator<<(std::ostream &os, Gender gender) { 8 | os << ((gender == Gender::Male) ? "Male" : "Female"); 9 | return os; 10 | } 11 | 12 | struct User { 13 | std::string username; 14 | Gender gender; 15 | }; 16 | 17 | namespace rc { 18 | 19 | template <> 20 | struct Arbitrary { 21 | static Gen arbitrary() { 22 | return gen::build( 23 | gen::set(&User::username), 24 | gen::set(&User::gender, gen::element(Gender::Male, Gender::Female))); 25 | } 26 | }; 27 | 28 | } // namespace rc 29 | 30 | int main() { 31 | rc::check("RC_TAG", [](const User &user) { RC_TAG(user.gender); }); 32 | 33 | rc::check("RC_CLASSIFY", 34 | [](const User &user) { RC_CLASSIFY(user.username.empty()); }); 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/counter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(counter main.cpp) 2 | 3 | target_link_libraries(counter rapidcheck) 4 | target_include_directories(counter PRIVATE ../../ext/catch/include) -------------------------------------------------------------------------------- /ext/rapidcheck/examples/database/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(database main.cpp 2 | Database.cpp 3 | DatabaseConnection.cpp 4 | User.cpp) 5 | 6 | target_link_libraries(database rapidcheck) -------------------------------------------------------------------------------- /ext/rapidcheck/examples/database/Database.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #include "User.h" 9 | 10 | class IDatabaseConnection; 11 | 12 | class Database { 13 | public: 14 | explicit Database(std::unique_ptr connection); 15 | 16 | void open(); 17 | void close(); 18 | void beginWrite(); 19 | void executeWrite(); 20 | void put(User user); 21 | bool get(const std::string &username, User &user); 22 | 23 | private: 24 | bool m_open; 25 | std::unique_ptr m_connection; 26 | std::map m_cache; 27 | bool m_hasBlock; 28 | std::vector m_queue; 29 | std::size_t m_hash; 30 | }; 31 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/database/DatabaseConnection.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | struct Message { 8 | Message() = default; 9 | Message(std::string t, 10 | std::vector p = std::vector()); 11 | 12 | std::string type; 13 | std::vector params; 14 | }; 15 | 16 | class IDatabaseConnection { 17 | public: 18 | virtual Message sendMessage(const Message &msg) = 0; 19 | virtual ~IDatabaseConnection() = default; 20 | }; 21 | 22 | std::unique_ptr connectToDatabase(const std::string &id); 23 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/gtest/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(gtest_integration main.cpp) 2 | target_link_libraries(gtest_integration rapidcheck_gtest gtest) 3 | target_include_directories(gtest_integration PRIVATE 4 | ${CMAKE_SOURCE_DIR}/ext/gmock/gtest/include) 5 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/mapparser/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(mapparser main.cpp MapParser.cpp) 2 | target_link_libraries(mapparser rapidcheck) -------------------------------------------------------------------------------- /ext/rapidcheck/examples/mapparser/MapParser.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | class ParseException : public std::exception { 8 | public: 9 | ParseException(std::string::size_type pos, const std::string &msg); 10 | std::string::size_type position() const; 11 | std::string message() const; 12 | const char *what() const noexcept override; 13 | 14 | private: 15 | std::string::size_type m_pos; 16 | std::string m_msg; 17 | std::string m_what; 18 | }; 19 | 20 | std::map parseMap(const std::string &str); 21 | 22 | std::string mapToString(const std::map &map, 23 | bool doubleQuote = false); 24 | -------------------------------------------------------------------------------- /ext/rapidcheck/examples/mapparser/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "MapParser.h" 4 | 5 | using namespace rc; 6 | 7 | int main() { 8 | rc::check("serializing and then parsing should yield original map", 9 | [](const std::map &map) { 10 | RC_PRE(map.find("") == map.end()); 11 | RC_ASSERT(parseMap(mapToString(map)) == map); 12 | }); 13 | } 14 | -------------------------------------------------------------------------------- /ext/rapidcheck/ext/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if (RC_ENABLE_TESTS OR RC_ENABLE_CATCH) 2 | add_library(catch INTERFACE) 3 | target_include_directories(catch INTERFACE catch/include) 4 | endif() 5 | 6 | if ((RC_ENABLE_GMOCK OR RC_ENABLE_GTEST) AND RC_ENABLE_TESTS) 7 | # On Windows, gmock/gtest defaults to static CRT which is not compatible 8 | # with the way RapidCheck is currently built 9 | set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) 10 | add_subdirectory(googletest) 11 | endif() 12 | 13 | if (RC_ENABLE_BOOST AND RC_ENABLE_TESTS) 14 | if (NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/boost") 15 | execute_process( 16 | COMMAND "sh" "get_boost.sh" 17 | WORKING_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}") 18 | endif() 19 | add_library(boost INTERFACE) 20 | target_include_directories(boost INTERFACE boost) 21 | endif() 22 | -------------------------------------------------------------------------------- /ext/rapidcheck/ext/get_boost.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | curl -s -L -o boost_1_59_0.tar.bz2 "http://downloads.sourceforge.net/project/boost/boost/1.59.0/boost_1_59_0.tar.bz2?r=http%3A%2F%2Fsourceforge.net%2Fprojects%2Fboost%2Ffiles%2Fboost%2F1.59.0%2Fboost_1_59_0.tar.bz2%2Fdownload&ts=1441133751&use_mirror=skylink" 3 | tar xjfp boost_1_59_0.tar.bz2 4 | mv boost_1_59_0 boost 5 | rm boost_1_59_0.tar.bz2 6 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | option(RC_ENABLE_CATCH "Build Catch.hpp support" OFF) 2 | if (RC_ENABLE_CATCH OR RC_ENABLE_TESTS) 3 | add_subdirectory(catch) 4 | endif() 5 | 6 | option(RC_ENABLE_GMOCK "Build Google Mock integration" OFF) 7 | if (RC_ENABLE_GMOCK) 8 | add_subdirectory(gmock) 9 | endif() 10 | 11 | option(RC_ENABLE_GTEST "Build Google Test integration" OFF) 12 | if (RC_ENABLE_GTEST) 13 | add_subdirectory(gtest) 14 | endif() 15 | 16 | option(RC_ENABLE_BOOST "Build Boost support" OFF) 17 | if (RC_ENABLE_BOOST) 18 | add_subdirectory(boost) 19 | endif() 20 | 21 | option(RC_ENABLE_BOOST_TEST "Build Boost Test support" OFF) 22 | if (RC_ENABLE_BOOST_TEST) 23 | add_subdirectory(boost_test) 24 | endif() 25 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/boost/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(rapidcheck_boost INTERFACE) 2 | target_link_libraries(rapidcheck_boost INTERFACE rapidcheck) 3 | target_include_directories(rapidcheck_boost INTERFACE include) 4 | 5 | if (RC_ENABLE_TESTS) 6 | add_subdirectory(test) 7 | endif() -------------------------------------------------------------------------------- /ext/rapidcheck/extras/boost/include/rapidcheck/boost.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "rapidcheck/gen/boost/Optional.h" 6 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/boost/include/rapidcheck/gen/boost/Optional.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace rc { 6 | namespace gen { 7 | namespace boost { 8 | 9 | /// Generates a `boost::optional` of values generated by the given generator. 10 | template 11 | Gen<::boost::optional> optional(Gen gen); 12 | 13 | } // namespace boost 14 | } // namespace gen 15 | } // namespace rc 16 | 17 | #include "Optional.hpp" 18 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/boost/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(rapidcheck_boost_tests 2 | main.cpp 3 | OptionalTests.cpp 4 | ) 5 | 6 | target_link_libraries(rapidcheck_boost_tests 7 | boost 8 | rapidcheck_boost 9 | rapidcheck_catch 10 | rapidcheck_test_utils 11 | catch) 12 | 13 | add_test( 14 | NAME rapidcheck_boost_tests 15 | COMMAND rapidcheck_boost_tests) -------------------------------------------------------------------------------- /ext/rapidcheck/extras/boost/test/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #if (__GLIBCXX__ / 10000) == 2014 3 | 4 | namespace std { 5 | 6 | inline bool uncaught_exception() noexcept(true) { 7 | return current_exception() != nullptr; 8 | } 9 | 10 | } // namespace std 11 | 12 | #endif 13 | 14 | #define CATCH_CONFIG_MAIN 15 | #include 16 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/boost_test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(rapidcheck_boost_test INTERFACE) 2 | target_link_libraries(rapidcheck_boost_test INTERFACE rapidcheck) 3 | target_include_directories(rapidcheck_boost_test INTERFACE include) 4 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/catch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(rapidcheck_catch INTERFACE) 2 | target_link_libraries(rapidcheck_catch INTERFACE rapidcheck) 3 | target_include_directories(rapidcheck_catch INTERFACE include) -------------------------------------------------------------------------------- /ext/rapidcheck/extras/gmock/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(rapidcheck_gmock INTERFACE) 2 | target_link_libraries(rapidcheck_gmock INTERFACE rapidcheck) 3 | target_include_directories(rapidcheck_gmock INTERFACE include) 4 | 5 | if (RC_ENABLE_TESTS) 6 | add_subdirectory(test) 7 | endif() -------------------------------------------------------------------------------- /ext/rapidcheck/extras/gmock/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(rapidcheck_gmock_tests main.cpp) 2 | target_link_libraries(rapidcheck_gmock_tests 3 | rapidcheck_gmock 4 | rapidcheck_catch 5 | catch 6 | gmock) 7 | target_include_directories(rapidcheck_gmock_tests PRIVATE 8 | ${CMAKE_SOURCE_DIR}/ext/googletest/googletest/include 9 | ${CMAKE_SOURCE_DIR}/ext/googletest/googlemock/include) 10 | 11 | # Prevent collision between Gmock and Catch 12 | target_compile_definitions(rapidcheck_gmock_tests PRIVATE 13 | CATCH_CONFIG_PREFIX_ALL) 14 | 15 | add_test( 16 | NAME rapidcheck_gmock_tests 17 | COMMAND rapidcheck_gmock_tests) 18 | -------------------------------------------------------------------------------- /ext/rapidcheck/extras/gtest/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(rapidcheck_gtest INTERFACE) 2 | target_link_libraries(rapidcheck_gtest INTERFACE rapidcheck) 3 | target_include_directories(rapidcheck_gtest INTERFACE include) 4 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/BeforeMinimalTestCase.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rc { 4 | 5 | /// This is called before the final minimal test case is run when a property 6 | /// fails. Set a breakpoint here if you want to debug that test case. When the 7 | /// debugger breaks here, you can set up any further breakpoints or other tools 8 | /// before the test case is actually run. 9 | void beforeMinimalTestCase(); 10 | 11 | } // namespace rc 12 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Check.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace rc { 6 | 7 | /// Checks the given testable and returns `true` on success and `false` on 8 | /// failure. This method will also print information about the testing to 9 | /// stderr. 10 | template 11 | bool check(Testable &&testable); 12 | 13 | /// Same as `check(Testable &&)` but also takes a description of the property 14 | /// that is being tested as the first parameter. This will be used in the 15 | /// output. 16 | template 17 | bool check(const std::string &description, Testable &&testable); 18 | 19 | } // namespace rc 20 | 21 | #include "Check.hpp" 22 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Classify.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /// Tags the current test case if the specified condition is true. If any tags 4 | /// are specified after the condition, those will be used. Otherwise, a string 5 | /// version of the condition itself will be used as the tag. 6 | #define RC_CLASSIFY(condition, ...) \ 7 | do { \ 8 | if (condition) { \ 9 | ::rc::detail::classify(#condition, {__VA_ARGS__}); \ 10 | } \ 11 | } while (false) 12 | 13 | /// Tags the current test case with the given values which will be converted to 14 | /// strings. 15 | #define RC_TAG(...) ::rc::detail::tag({__VA_ARGS__}) 16 | 17 | #include "Classify.hpp" 18 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Classify.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace rc { 6 | namespace detail { 7 | 8 | struct Stringified { 9 | template 10 | Stringified(const T &value) 11 | : str(toString(value)) {} 12 | std::string str; 13 | }; 14 | 15 | void tag(std::initializer_list tags); 16 | void classify(std::string condition, std::initializer_list tags); 17 | 18 | } // namespace detail 19 | } // namespace rc 20 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/GenerationFailure.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace rc { 6 | 7 | /// Thrown to indicate that an appropriate value couldn't be generated. 8 | class GenerationFailure : public std::runtime_error { 9 | public: 10 | explicit GenerationFailure(std::string msg); 11 | }; 12 | 13 | } // namespace rc 14 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Log.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | /// Logs additional information about the run of a test case. Can be used either 6 | /// like a stream (`RC_LOG() << "foobar"`) or taking a string 7 | /// (`RC_LOG("foobar")`). When using the latter form, a newline will be appended 8 | /// automatically. 9 | #define RC_LOG(...) ::rc::detail::log(__VA_ARGS__) 10 | 11 | #include "Log.hpp" 12 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Log.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rc { 4 | namespace detail { 5 | 6 | /// Returns the current logging stream. 7 | std::ostream &log(); 8 | 9 | /// Logs the given message. 10 | void log(const std::string &msg); 11 | 12 | } // namespace detail 13 | } // namespace rc 14 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Nothing.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace rc { 4 | 5 | /// Tag struct that can be used to construct different types to an uninitialized 6 | /// or empty state. 7 | struct NothingType { 8 | /// Explicit conversion to false. 9 | explicit operator bool() const { return false; } 10 | }; 11 | 12 | /// Singleton NothingType value. 13 | constexpr NothingType Nothing = NothingType(); 14 | 15 | } // namespace rc 16 | -------------------------------------------------------------------------------- /ext/rapidcheck/include/rapidcheck/Traits.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "rapidcheck/detail/IntSequence.h" 6 | 7 | namespace rc { 8 | 9 | /// Convenience wrapper over std::decay, shorter to type. 10 | template 11 | using Decay = typename std::decay::type; 12 | 13 | /// Checks that all the parameters are true. 14 | template 15 | struct AllTrue 16 | : public std::is_same, 17 | detail::IntSequence> {}; 18 | 19 | /// Checks that all the types in `Ts` conforms to type trait `F`. 20 | template