From e8e06bed7fedfacddf5caa7b1bd785f1fdd724de Mon Sep 17 00:00:00 2001 From: Roberto Martin Fantini Date: Fri, 28 Feb 2025 18:08:25 +0100 Subject: [PATCH 1/2] Correct the case of the constant or default length --- src/mfast/ext_ref.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/mfast/ext_ref.h b/src/mfast/ext_ref.h index 522a92d5..9dc4338a 100644 --- a/src/mfast/ext_ref.h +++ b/src/mfast/ext_ref.h @@ -10,6 +10,8 @@ #include "decimal_ref.h" #include "nested_message_ref.h" +#include + namespace mfast { template struct fast_operator_tag : std::integral_constant {}; @@ -147,6 +149,13 @@ class ext_cref { explicit ext_cref(const field_cref &other) : base_(other) {} cref_type get() const { return base_; } length_type get_length(value_storage &storage) const { + if (std::is_same::value) + storage = base_.instruction()->length_instruction()->initial_value(); + else if (std::is_same::value) + storage = base_.instruction()->length_instruction()->prev_value(); + else if (std::is_same::value) + storage = base_.instruction()->length_instruction()->initial_or_default_value(); + uint32_mref length_mref(nullptr, &storage, base_.instruction()->length_instruction()); length_mref.as(base_.size()); @@ -327,6 +336,13 @@ class ext_mref { cref_type get() const { return base_; } is_optional_type optional() const { return is_optional_type(); } length_type set_length(value_storage &storage) const { + if (std::is_same::value) + storage = base_.instruction()->length_instruction()->initial_value(); + else if (std::is_same::value) + storage = base_.instruction()->length_instruction()->prev_value(); + else if (std::is_same::value) + storage = base_.instruction()->length_instruction()->initial_or_default_value(); + field_mref_base length_mref(nullptr, &storage, base_.instruction()->length_instruction()); return length_type(length_mref); From 62629b2fd8a9fb97091dedfbdcc2742a682357d1 Mon Sep 17 00:00:00 2001 From: Roberto Martin Fantini Date: Fri, 28 Feb 2025 18:15:42 +0100 Subject: [PATCH 2/2] Add unit tests --- tests/CMakeLists.txt | 4 + tests/sequence_encoder_decoder.cpp | 133 ++++++++++++++++++++++++++ tests/sequence_encoder_decoder_v2.cpp | 133 ++++++++++++++++++++++++++ tests/simple14.xml | 31 ++++++ 4 files changed, 301 insertions(+) create mode 100644 tests/sequence_encoder_decoder.cpp create mode 100644 tests/sequence_encoder_decoder_v2.cpp create mode 100644 tests/simple14.xml diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 3f652e20..7abb7b65 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -21,6 +21,7 @@ FASTTYPEGEN_TARGET(simple_types9 simple9.xml) FASTTYPEGEN_TARGET(simple_types10 simple10.xml) FASTTYPEGEN_TARGET(simple_types11 simple11.xml) FASTTYPEGEN_TARGET(simple_types12 simple12.xml) +FASTTYPEGEN_TARGET(simple_types14 simple14.xml) FASTTYPEGEN_TARGET(test_types1 test1.xml test2.xml) @@ -60,6 +61,7 @@ add_executable (mfast_test ${FASTTYPEGEN_simple_types10_OUTPUTS} ${FASTTYPEGEN_simple_types11_OUTPUTS} ${FASTTYPEGEN_simple_types12_OUTPUTS} + ${FASTTYPEGEN_simple_types14_OUTPUTS} fast_type_gen_test.cpp dictionary_builder_test.cpp json_test.cpp @@ -67,6 +69,8 @@ add_executable (mfast_test composite_type_test.cpp aggregate_view_test.cpp simple_coder_test.cpp + sequence_encoder_decoder_v2.cpp + sequence_encoder_decoder_v2.cpp scp_reset_test.cpp template_repo_base.cpp message_pmap_test.cpp diff --git a/tests/sequence_encoder_decoder.cpp b/tests/sequence_encoder_decoder.cpp new file mode 100644 index 00000000..59bd9d29 --- /dev/null +++ b/tests/sequence_encoder_decoder.cpp @@ -0,0 +1,133 @@ +#include "catch.hpp" +#include + +#include "fast_test_coding_case.hpp" +#include "byte_stream.h" + +#include "simple14.h" + +using namespace test::coding; + +TEST_CASE("sequence optional copy operator by length encoder/decoder","[sequence_copy_operator_length_encoder_decoder]") +{ + fast_test_coding_case test_case; + simple14::Test_1 test_1; + simple14::Test_1_mref test_1_mref = test_1.mref(); + auto sequence_1_mref = test_1_mref.set_sequence_1(); + sequence_1_mref.resize(1); + + auto element_sequence = sequence_1_mref.front(); + element_sequence.set_field_1_2().as(50); + + test_1_mref.set_field_1_3().as(10); + + REQUIRE(test_case.encoding(test_1.cref(),"\xE0\x81\x82\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xE0\x81\x82\xC0\xB3\x8B",test_1.cref(),true)); +} + +TEST_CASE("sequence optional constant operator by length encoder/decoder","[sequence_constant_operator_length_encoder_decoder]") +{ + fast_test_coding_case test_case; + simple14::Test_2 test_2; + simple14::Test_2 test_3; + + { + simple14::Test_2_mref test_2_mref = test_2.mref(); + + auto sequence_2_mref = test_2_mref.set_sequence_2(); + // First time hast to be initalized and the same value from the configuration xml + sequence_2_mref.resize(1); + + auto element_sequence = sequence_2_mref.front(); + element_sequence.set_field_2_2().as(50); + + test_2_mref.set_field_2_3().as(10); + + REQUIRE(test_case.encoding(test_2.cref(),"\xE0\x82\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xE0\x82\xC0\xB3\x8B",test_2.cref(),true)); + } + { + simple14::Test_2_mref test_3_mref = test_3.mref(); + + auto sequence_3_mref = test_3_mref.set_sequence_2(); + sequence_3_mref.resize(2); + + { + auto element_sequence = sequence_3_mref.front(); + element_sequence.set_field_2_2().as(50); + } + + { + auto element_sequence = sequence_3_mref.back(); + element_sequence.set_field_2_2().as(60); + } + + test_3_mref.set_field_2_3().as(10); + + REQUIRE(test_case.encoding(test_3.cref(),"\xA0\x80\xC0\xBD\x8B")); + } +} + +TEST_CASE("sequence optional default operator by length encoder/decoder","[sequence_default_operator_length_encoder_decoder]") +{ + fast_test_coding_case test_case; + simple14::Test_3 test_3; + simple14::Test_3 test_4; + + { + simple14::Test_3_mref test_3_mref = test_3.mref(); + + auto sequence_3_mref = test_3_mref.set_sequence_3(); + // First time hast to be initalized and the same value from the configuration xml + sequence_3_mref.resize(1); + + auto element_sequence = sequence_3_mref.front(); + element_sequence.set_field_3_2().as(50); + + test_3_mref.set_field_3_3().as(10); + + REQUIRE(test_case.encoding(test_3.cref(),"\xC0\x83\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xC0\x83\xC0\xB3\x8B",test_3.cref(),true)); + } + + { + simple14::Test_3_mref test_4_mref = test_4.mref(); + + auto sequence_4_mref = test_4_mref.set_sequence_3(); + sequence_4_mref.resize(2); + + { + auto element_sequence = sequence_4_mref.front(); + element_sequence.set_field_3_2().as(50); + } + + { + auto element_sequence = sequence_4_mref.front(); + element_sequence.set_field_3_2().as(60); + } + + test_4_mref.set_field_3_3().as(10); + + REQUIRE(test_case.encoding(test_4.cref(),"\xA0\x83\xC0\xBD\xC0\x80\x8B")); + } +} + +TEST_CASE("sequence optional none operator by length encoder/decoder","[sequence_default_none_length_encoder_decoder]") +{ + fast_test_coding_case test_case; + simple14::Test_4 test_4; + simple14::Test_4_mref test_4_mref = test_4.mref(); + + auto sequence_4_mref = test_4_mref.set_sequence_4(); + sequence_4_mref.resize(1); + + auto element_sequence = sequence_4_mref.front(); + element_sequence.set_field_4_2().as(50); + + test_4_mref.set_field_4_3().as(10); + + REQUIRE(test_case.encoding(test_4.cref(),"\xC0\x84\x82\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xC0\x84\x82\xC0\xB3\x8B",test_4.cref(),true)); +} + + diff --git a/tests/sequence_encoder_decoder_v2.cpp b/tests/sequence_encoder_decoder_v2.cpp new file mode 100644 index 00000000..a7cc992f --- /dev/null +++ b/tests/sequence_encoder_decoder_v2.cpp @@ -0,0 +1,133 @@ +#include "catch.hpp" +#include + +#include "fast_test_coding_case_v2.hpp" +#include "byte_stream.h" + +#include "simple14.h" + +using namespace test::coding; + +TEST_CASE("sequence optional copy operator by length encoder_V2/decoder_v2","[sequence_copy_operator_length_encoder_v2_decoder_v2]") +{ + fast_test_coding_case_v2 test_case; + simple14::Test_1 test_1; + simple14::Test_1_mref test_1_mref = test_1.mref(); + auto sequence_1_mref = test_1_mref.set_sequence_1(); + sequence_1_mref.resize(1); + + auto element_sequence = sequence_1_mref.front(); + element_sequence.set_field_1_2().as(50); + + test_1_mref.set_field_1_3().as(10); + + REQUIRE(test_case.encoding(test_1.cref(),"\xE0\x81\x82\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xE0\x81\x82\xC0\xB3\x8B",test_1.cref(),true)); +} + +TEST_CASE("sequence optional constant operator by length encoder_V2/decoder_v2","[sequence_constant_operator_length_encoder_v2_decoder_v2]") +{ + fast_test_coding_case_v2 test_case; + simple14::Test_2 test_2; + simple14::Test_2 test_3; + + { + simple14::Test_2_mref test_2_mref = test_2.mref(); + + auto sequence_2_mref = test_2_mref.set_sequence_2(); + // First time hast to be initalized and the same value from the configuration xml + sequence_2_mref.resize(1); + + auto element_sequence = sequence_2_mref.front(); + element_sequence.set_field_2_2().as(50); + + test_2_mref.set_field_2_3().as(10); + + REQUIRE(test_case.encoding(test_2.cref(),"\xE0\x82\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xE0\x82\xC0\xB3\x8B",test_2.cref(),true)); + } + { + simple14::Test_2_mref test_3_mref = test_3.mref(); + + auto sequence_3_mref = test_3_mref.set_sequence_2(); + sequence_3_mref.resize(2); + + { + auto element_sequence = sequence_3_mref.front(); + element_sequence.set_field_2_2().as(50); + } + + { + auto element_sequence = sequence_3_mref.back(); + element_sequence.set_field_2_2().as(60); + } + + test_3_mref.set_field_2_3().as(10); + + REQUIRE(test_case.encoding(test_3.cref(),"\xA0\x80\xC0\xBD\x8B")); + } +} + +TEST_CASE("sequence optional default operator by length encoder_V2/decoder_v2","[sequence_default_operator_length_encoder_v2_decoder_v2]") +{ + fast_test_coding_case_v2 test_case; + simple14::Test_3 test_3; + simple14::Test_3 test_4; + + { + simple14::Test_3_mref test_3_mref = test_3.mref(); + + auto sequence_3_mref = test_3_mref.set_sequence_3(); + // First time hast to be initalized and the same value from the configuration xml + sequence_3_mref.resize(1); + + auto element_sequence = sequence_3_mref.front(); + element_sequence.set_field_3_2().as(50); + + test_3_mref.set_field_3_3().as(10); + + REQUIRE(test_case.encoding(test_3.cref(),"\xC0\x83\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xC0\x83\xC0\xB3\x8B",test_3.cref(),true)); + } + + { + simple14::Test_3_mref test_4_mref = test_4.mref(); + + auto sequence_4_mref = test_4_mref.set_sequence_3(); + sequence_4_mref.resize(2); + + { + auto element_sequence = sequence_4_mref.front(); + element_sequence.set_field_3_2().as(50); + } + + { + auto element_sequence = sequence_4_mref.front(); + element_sequence.set_field_3_2().as(60); + } + + test_4_mref.set_field_3_3().as(10); + + REQUIRE(test_case.encoding(test_4.cref(),"\xA0\x83\xC0\xBD\xC0\x80\x8B")); + } + + // REQUIRE(test_case.decoding("\x80\x80\x8B", test_3.cref())); +} + +TEST_CASE("sequence optional none operator by length encoder_V2/decoder_v2","[sequence_default_none_length_encoder_v2_decoder_v2]") +{ + fast_test_coding_case_v2 test_case; + simple14::Test_4 test_4; + simple14::Test_4_mref test_4_mref = test_4.mref(); + + auto sequence_4_mref = test_4_mref.set_sequence_4(); + sequence_4_mref.resize(1); + + auto element_sequence = sequence_4_mref.front(); + element_sequence.set_field_4_2().as(50); + + test_4_mref.set_field_4_3().as(10); + + REQUIRE(test_case.encoding(test_4.cref(),"\xC0\x84\x82\xC0\xB3\x8B",true)); + REQUIRE(test_case.decoding("\xC0\x84\x82\xC0\xB3\x8B",test_4.cref(),true)); +} diff --git a/tests/simple14.xml b/tests/simple14.xml new file mode 100644 index 00000000..97390a38 --- /dev/null +++ b/tests/simple14.xml @@ -0,0 +1,31 @@ + + + + + + +