diff options
| -rw-r--r-- | src/core/common/VariantConverter.cpp | 27 | ||||
| -rw-r--r-- | src/core/common/VariantConverter.hpp | 19 | ||||
| -rw-r--r-- | src/core/common/VariantReader.cpp | 20 | ||||
| -rw-r--r-- | test/core/common/VariantConverterTest.cpp | 362 |
4 files changed, 401 insertions, 27 deletions
diff --git a/src/core/common/VariantConverter.cpp b/src/core/common/VariantConverter.cpp index 03eb2e8..ff7c5a1 100644 --- a/src/core/common/VariantConverter.cpp +++ b/src/core/common/VariantConverter.cpp @@ -22,12 +22,14 @@ #include <string> #include <sstream> +#include "CharReader.hpp" #include "Function.hpp" #include "Logger.hpp" #include "Number.hpp" #include "Rtti.hpp" #include "Variant.hpp" #include "VariantConverter.hpp" +#include "VariantReader.hpp" #include "VariantWriter.hpp" namespace ousia { @@ -389,9 +391,11 @@ bool VariantConverter::toMap(Variant &var, const Rtti &innerType, bool VariantConverter::toCardinality(Variant &var, Logger &logger, Mode mode) { + if (var.isCardinality()) { + return true; + } // Perform safe conversions (all these operations are considered "lossless") - const VariantType type = var.getType(); - if (type == VariantType::INT) { + if (var.isInt()) { int value = var.asInt(); var.setCardinality(Variant::cardinalityType{}); Variant::cardinalityType &card = var.asCardinality(); @@ -406,6 +410,7 @@ bool VariantConverter::toCardinality(Variant &var, Logger &logger, Mode mode) // Perform lossy conversions if (mode == Mode::ALL) { + const VariantType type = var.getType(); switch (type) { case VariantType::NULLPTR: var.setCardinality(Variant::cardinalityType{}); @@ -465,11 +470,11 @@ bool VariantConverter::toCardinality(Variant &var, Logger &logger, Mode mode) return false; } int end = endVar.asInt(); - if (end <= start) { + if (end < start) { logger.error( std::string("The supposed start value ") + std::to_string(start) + - " was bigger or equal to the supposed end value " + + " was bigger than the supposed end value " + std::to_string(end) + " of the Range."); return false; } @@ -479,11 +484,15 @@ bool VariantConverter::toCardinality(Variant &var, Logger &logger, Mode mode) return true; } case VariantType::STRING: { - var.setCardinality(Variant::cardinalityType{}); - // Variant::cardinalityType &card = - // var.asCardinality(); - // TODO: Implement! - return false; + CharReader reader{var.asString().c_str()}; + auto res = VariantReader::parseCardinality(reader, logger); + if (res.first) { + var.setCardinality(res.second); + return true; + } else { + var.setCardinality(Variant::cardinalityType{}); + return false; + } } default: break; diff --git a/src/core/common/VariantConverter.hpp b/src/core/common/VariantConverter.hpp index 7e317a2..92cc40a 100644 --- a/src/core/common/VariantConverter.hpp +++ b/src/core/common/VariantConverter.hpp @@ -84,10 +84,10 @@ public: * to Mode::SAFE, only integers can be converted to integers. For all other * types the conversion fails. If "mode" is set to Mode::ALL, booleans are * converted to 0, 1, nullptr is converted to 0, doubles are truncated, - * strings are parsed and truncated, arrays with one element are converted - * to an integer. Conversion fails for objects, functions, maps and arrays - * with zero or more than one entry. If the conversion fails, 0 is returned - * as default value. + * strings are parsed and truncated, arrays and cardinalities with one + * element are converted to an integer. Conversion fails for objects, + * functions, maps and arrays with zero or more than one entry. If the + * conversion fails, 0 is returned as default value. * * @param var is instance of the Variant class that should be converted to * the requested type. @@ -105,7 +105,8 @@ public: * to Mode::SAFE, only integers and doubles can be converted to doubles. For * all other types the conversion fails. If "mode" is set to Mode::ALL, * booleans are converted to 0.0, 1.0, nullptr is converted to 0.0, strings - * are parsed, arrays with one element are converted to a double. + * are parsed, arrays and cardinalities with one element are converted to a + * double. * Conversion fails for objects, functions, maps and arrays with zero or * more than one entry. If the conversion fails, 0.0 is returned as default * value. @@ -125,10 +126,10 @@ public: * Converts the given variant to a string. If the "mode" parameter is set * to Mode::SAFE, all primitive types can be converted to strings. For * all other types the conversion fails. If "mode" is set to Mode::ALL, - * maps and arrays are converted to a JSON representation, objects and - * functions are converted to an informative string containing their pointer - * and type. If the conversion fails, an empty string is returned as default - * value. + * maps and arrays are converted to a JSON representation, cardinalities + * to their parsing syntax and objects and functions are converted to an + * informative string containing their pointer and type. If the conversion + * fails, an empty string is returned as default value. * * @param var is instance of the Variant class that should be converted to * the requested type. diff --git a/src/core/common/VariantReader.cpp b/src/core/common/VariantReader.cpp index bbceac5..7320973 100644 --- a/src/core/common/VariantReader.cpp +++ b/src/core/common/VariantReader.cpp @@ -518,7 +518,7 @@ std::pair<bool, Variant::mapType> VariantReader::parseObject(CharReader &reader, return std::make_pair(res.first, res.second.asMap()); } -static const std::unordered_set<char> cardDelims{' ', ',', '}'}; +static const std::unordered_set<char> cardDelims{' ', ',', '}', '-'}; std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( CharReader &reader, Logger &logger) @@ -533,6 +533,7 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( Variant::cardinalityType card{}; + reader.consumePeek(); reader.consumeWhitespace(); // which should in turn be followed by ranges. @@ -541,14 +542,15 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( // in case of a numeric character we want to read an integer. reader.resetPeek(); Number n; - n.parse(reader, logger, cardDelims); - if (!n.isInt() || n.intValue() < 0) { + if (!n.parse(reader, logger, cardDelims) || !n.isInt() || + n.intValue() < 0) { return error(reader, logger, "Invalid number for cardinality!", Variant::cardinalityType{}); } unsigned int start = (unsigned int)n.intValue(); // if we have that we might either find a } or , making this a // range or a - leading us to expect another integer. + reader.consumePeek(); reader.consumeWhitespace(); if (!reader.peek(c)) { error(reader, logger, ERR_UNEXPECTED_END, @@ -560,16 +562,16 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( reader.resetPeek(); break; case '-': { - reader.consumePeek(); // get another integer. + reader.consumePeek(); reader.consumeWhitespace(); if (!reader.peek(c)) { error(reader, logger, ERR_UNEXPECTED_END, Variant::cardinalityType{}); } Number n2; - n2.parse(reader, logger, cardDelims); - if (!n2.isInt() || n2.intValue() < 0) { + if (!n2.parse(reader, logger, cardDelims) || !n2.isInt() || + n2.intValue() < 0) { return error(reader, logger, "Invalid number for cardinality!", Variant::cardinalityType{}); @@ -583,9 +585,6 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( return unexpected(reader, logger, "}, , or -", c, Variant::cardinalityType{}); } - if (c == '{' || c == ',') { - reader.resetPeek(); - } } else { switch (c) { case '*': @@ -596,6 +595,7 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( case '<': case '>': { // in case of an open range we expect a number. + reader.consumePeek(); reader.consumeWhitespace(); Number n; if (!n.parse(reader, logger, cardDelims)) { @@ -625,6 +625,7 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( } } // after we have parsed a range, read all whitespaces. + reader.consumePeek(); reader.consumeWhitespace(); // ... and check if we are at the end. if (!reader.read(c)) { @@ -635,6 +636,7 @@ std::pair<bool, Variant::cardinalityType> VariantReader::parseCardinality( case '}': return std::make_pair(true, card); case ',': + reader.consumePeek(); reader.consumeWhitespace(); break; diff --git a/test/core/common/VariantConverterTest.cpp b/test/core/common/VariantConverterTest.cpp index a655aa0..ab18f14 100644 --- a/test/core/common/VariantConverterTest.cpp +++ b/test/core/common/VariantConverterTest.cpp @@ -41,6 +41,7 @@ TEST(VariantConverter, toBool) { // setup Logger logger; + Variant n = nullptr; Variant b = true; Variant i = 0; Variant d = 2.3; @@ -52,6 +53,8 @@ TEST(VariantConverter, toBool) Variant C = card; // in safe mode only bool to bool conversion should be possible. + assertBoolConversion(n, nullptr, false, VariantConverter::Mode::SAFE, + logger); assertBoolConversion(b, b, true, VariantConverter::Mode::SAFE, logger); assertBoolConversion(i, nullptr, false, VariantConverter::Mode::SAFE, logger); @@ -67,6 +70,7 @@ TEST(VariantConverter, toBool) logger); // in all mode more should be possible. + assertBoolConversion(n, false, true, VariantConverter::Mode::ALL, logger); assertBoolConversion(b, b, true, VariantConverter::Mode::ALL, logger); assertBoolConversion(i, false, true, VariantConverter::Mode::ALL, logger); assertBoolConversion(d, true, true, VariantConverter::Mode::ALL, logger); @@ -92,6 +96,7 @@ TEST(VariantConverter, toInt) { // setup Logger logger; + Variant n = nullptr; Variant b = true; Variant i = 6; Variant d = 2.7; @@ -103,6 +108,8 @@ TEST(VariantConverter, toInt) Variant C = card; // in safe mode only int to int conversion should be possible. + assertIntConversion(n, nullptr, false, VariantConverter::Mode::SAFE, + logger); assertIntConversion(b, nullptr, false, VariantConverter::Mode::SAFE, logger); assertIntConversion(i, i, true, VariantConverter::Mode::SAFE, logger); @@ -118,6 +125,7 @@ TEST(VariantConverter, toInt) logger); // in all mode more should be possible. + assertIntConversion(n, 0, true, VariantConverter::Mode::ALL, logger); assertIntConversion(b, 1, true, VariantConverter::Mode::ALL, logger); assertIntConversion(i, i, true, VariantConverter::Mode::ALL, logger); assertIntConversion(d, 2, true, VariantConverter::Mode::ALL, logger); @@ -126,5 +134,359 @@ TEST(VariantConverter, toInt) assertIntConversion(M, nullptr, false, VariantConverter::Mode::ALL, logger); assertIntConversion(C, 4, true, VariantConverter::Mode::ALL, logger); } + +static void assertDoubleConversion(Variant conv, Variant expected, + bool expectedSuccess, + VariantConverter::Mode mode, Logger &logger) +{ + EXPECT_EQ(expectedSuccess, VariantConverter::toDouble(conv, logger, mode)); + if (expectedSuccess) { + EXPECT_EQ(expected, conv); + } +} + +TEST(VariantConverter, toDouble) +{ + // setup + Logger logger; + Variant n = nullptr; + Variant b = true; + Variant i = 6; + Variant d = 2.7; + Variant s = "test"; + Variant A = Variant::arrayType{d}; + Variant M = Variant::mapType{{"b", b}, {"i", i}, {"d", d}, {"s", s}}; + Variant::cardinalityType card; + card.merge({4}); + Variant C = card; + + // in safe mode only int to double and double to double conversion should be + // possible. + assertDoubleConversion(n, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertDoubleConversion(b, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertDoubleConversion(i, 6.0, true, VariantConverter::Mode::SAFE, logger); + assertDoubleConversion(d, d, true, VariantConverter::Mode::SAFE, logger); + assertDoubleConversion(s, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertDoubleConversion(A, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertDoubleConversion(M, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertDoubleConversion(C, nullptr, false, VariantConverter::Mode::SAFE, + logger); + + // in all mode more should be possible. + assertDoubleConversion(n, 0.0, true, VariantConverter::Mode::ALL, logger); + assertDoubleConversion(b, 1.0, true, VariantConverter::Mode::ALL, logger); + assertDoubleConversion(i, 6.0, true, VariantConverter::Mode::ALL, logger); + assertDoubleConversion(d, d, true, VariantConverter::Mode::ALL, logger); + assertDoubleConversion(s, nullptr, false, VariantConverter::Mode::ALL, + logger); + assertDoubleConversion(A, d, true, VariantConverter::Mode::ALL, logger); + assertDoubleConversion(M, nullptr, false, VariantConverter::Mode::ALL, + logger); + assertDoubleConversion(C, 4.0, true, VariantConverter::Mode::ALL, logger); +} + +static void assertStringConversion(Variant conv, Variant expected, + bool expectedSuccess, + VariantConverter::Mode mode, Logger &logger) +{ + EXPECT_EQ(expectedSuccess, VariantConverter::toString(conv, logger, mode)); + if (expectedSuccess) { + EXPECT_EQ(expected, conv); + } +} + +TEST(VariantConverter, toString) +{ + // setup + Logger logger; + Variant n = nullptr; + Variant b = true; + Variant i = 6; + Variant d = 2.7; + Variant s = "test"; + Variant A = Variant::arrayType{b, i, d, s}; + Variant M = Variant::mapType{{"b", b}, {"i", i}, {"d", d}, {"s", s}}; + Variant::cardinalityType card; + card.merge({2, 4}); + card.merge(Variant::rangeType::typeRangeFrom(7)); + Variant C = card; + + // in safe mode only primitive types should be converted to strings. + assertStringConversion(n, "null", true, VariantConverter::Mode::SAFE, + logger); + assertStringConversion(b, "true", true, VariantConverter::Mode::SAFE, + logger); + assertStringConversion(i, "6", true, VariantConverter::Mode::SAFE, logger); + assertStringConversion(d, "2.7", true, VariantConverter::Mode::SAFE, + logger); + assertStringConversion(s, s, true, VariantConverter::Mode::SAFE, logger); + assertStringConversion(A, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertStringConversion(M, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertStringConversion(C, nullptr, false, VariantConverter::Mode::SAFE, + logger); + + // in all mode more should be possible. + assertStringConversion(n, "null", true, VariantConverter::Mode::ALL, + logger); + assertStringConversion(b, "true", true, VariantConverter::Mode::ALL, + logger); + assertStringConversion(i, "6", true, VariantConverter::Mode::ALL, logger); + assertStringConversion(d, "2.7", true, VariantConverter::Mode::ALL, logger); + assertStringConversion(s, s, true, VariantConverter::Mode::ALL, logger); + assertStringConversion(A, "[true,6,2.7,\"test\"]", true, + VariantConverter::Mode::ALL, logger); + assertStringConversion(M, "{\"b\":true,\"d\":2.7,\"i\":6,\"s\":\"test\"}", + true, VariantConverter::Mode::ALL, logger); + assertStringConversion(C, "<cardinality {2-4, >6}>", true, + VariantConverter::Mode::ALL, logger); +} + +static void assertArrayConversion(Variant conv, Variant expected, + bool expectedSuccess, const Rtti &innerType, + VariantConverter::Mode mode, Logger &logger) +{ + EXPECT_EQ(expectedSuccess, + VariantConverter::toArray(conv, innerType, logger, mode)); + if (expectedSuccess) { + EXPECT_EQ(expected, conv); + } +} + +TEST(VariantConverter, toArray) +{ + // setup + Logger logger; + Variant n = nullptr; + Variant b = true; + Variant i = 6; + Variant d = 2.7; + Variant s = "9"; + Variant A = Variant::arrayType{b, i, d, s}; + Variant M = Variant::mapType{{"b", b}, {"i", i}, {"d", d}, {"s", s}}; + Variant::cardinalityType card; + card.merge({2, 4}); + card.merge(Variant::rangeType::typeRangeFrom(7)); + Variant C = card; + + // in safe mode only array to array conversion should be possible. + assertArrayConversion(n, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(b, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(i, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(d, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(s, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(A, A, true, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(M, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertArrayConversion(C, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + + // in all mode more should be possible. + assertArrayConversion(n, Variant::arrayType{n}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(b, Variant::arrayType{b}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(i, Variant::arrayType{i}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(d, Variant::arrayType{d}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(s, Variant::arrayType{s}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(A, A, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(M, Variant::arrayType{M}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertArrayConversion(C, Variant::arrayType{C}, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + // as an example also check the inner type converion + assertArrayConversion( + A, Variant::arrayType{Variant(1), Variant(6), Variant(2), Variant(9)}, + true, RttiTypes::Int, VariantConverter::Mode::ALL, logger); +} + +static void assertMapConversion(Variant conv, Variant expected, + bool expectedSuccess, const Rtti &innerType, + VariantConverter::Mode mode, Logger &logger) +{ + EXPECT_EQ(expectedSuccess, + VariantConverter::toMap(conv, innerType, logger, mode)); + if (expectedSuccess) { + EXPECT_EQ(expected, conv); + } +} + +TEST(VariantConverter, toMap) +{ + // setup + Logger logger; + Variant n = nullptr; + Variant b = true; + Variant i = 6; + Variant d = 2.7; + Variant s = "9"; + Variant A = Variant::arrayType{b, i, d, s}; + Variant M = Variant::mapType{{"b", b}, {"i", i}, {"d", d}, {"s", s}}; + Variant::cardinalityType card; + card.merge({2, 4}); + card.merge(Variant::rangeType::typeRangeFrom(7)); + Variant C = card; + + // in safe mode only map to map conversion should be possible. + assertMapConversion(n, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(b, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(i, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(d, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(s, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(A, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(M, M, true, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + assertMapConversion(C, nullptr, false, RttiTypes::None, + VariantConverter::Mode::SAFE, logger); + + // in all mode that should be the same. + assertMapConversion(n, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(b, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(i, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(d, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(s, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(A, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(M, M, true, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + assertMapConversion(C, nullptr, false, RttiTypes::None, + VariantConverter::Mode::ALL, logger); + + // but we should be able to convert the inner type. + assertMapConversion(M, Variant::mapType{{"b", Variant(1)}, + {"i", Variant(6)}, + {"d", Variant(2)}, + {"s", Variant(9)}}, + true, RttiTypes::Int, VariantConverter::Mode::ALL, + logger); + // which should not work in SAFE mode. + assertMapConversion(M, Variant::mapType{{"b", Variant(1)}, + {"i", Variant(6)}, + {"d", Variant(2)}, + {"s", Variant(9)}}, + false, RttiTypes::Int, VariantConverter::Mode::SAFE, + logger); +} + +static void assertCardinalityConversion(Variant conv, Variant expected, + bool expectedSuccess, + VariantConverter::Mode mode, + Logger &logger) +{ + EXPECT_EQ(expectedSuccess, + VariantConverter::toCardinality(conv, logger, mode)); + if (expectedSuccess) { + EXPECT_EQ(expected, conv); + } +} + +TEST(VariantConverter, toCardinality) +{ + // setup + Logger logger; + Variant n = nullptr; + Variant b = true; + Variant i = 6; + Variant d = 2.7; + Variant s = "{2-3, >9}"; + Variant A = + Variant::arrayType{Variant(2), Variant(7), Variant(10), Variant(10)}; + Variant M = Variant::mapType{{"b", b}, {"i", i}, {"d", d}, {"s", s}}; + Variant::cardinalityType card; + card.merge({2, 4}); + card.merge(Variant::rangeType::typeRangeFrom(7)); + Variant C = card; + + // in safe mode only ints and cardinalities should be convertible. + assertCardinalityConversion(n, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertCardinalityConversion(b, nullptr, false, VariantConverter::Mode::SAFE, + logger); + { + Variant::cardinalityType expected; + expected.merge({6}); + assertCardinalityConversion(i, expected, true, + VariantConverter::Mode::SAFE, logger); + } + assertCardinalityConversion(d, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertCardinalityConversion(s, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertCardinalityConversion(A, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertCardinalityConversion(M, nullptr, false, VariantConverter::Mode::SAFE, + logger); + assertCardinalityConversion(C, C, true, VariantConverter::Mode::SAFE, + logger); + + // in all mode more should be possible. + assertCardinalityConversion(n, Variant::cardinalityType{}, true, + VariantConverter::Mode::ALL, logger); + + { + Variant::cardinalityType expected; + expected.merge({Variant::rangeType::typeRange()}); + assertCardinalityConversion(b, expected, true, + VariantConverter::Mode::ALL, logger); + } + { + Variant::cardinalityType expected; + expected.merge({6}); + assertCardinalityConversion(i, expected, true, + VariantConverter::Mode::ALL, logger); + } + { + Variant::cardinalityType expected; + expected.merge({3}); + assertCardinalityConversion(d, expected, true, + VariantConverter::Mode::ALL, logger); + } + { + Variant::cardinalityType expected; + expected.merge({2, 3}); + expected.merge(Variant::rangeType::typeRangeFrom(10)); + assertCardinalityConversion(s, expected, true, + VariantConverter::Mode::ALL, logger); + } + { + Variant::cardinalityType expected; + expected.merge({2, 7}); + expected.merge({10}); + assertCardinalityConversion(A, expected, true, + VariantConverter::Mode::ALL, logger); + } + // for Map we still have no conversion + assertCardinalityConversion(M, nullptr, false, VariantConverter::Mode::ALL, + logger); + assertCardinalityConversion(C, C, true, VariantConverter::Mode::ALL, + logger); +} } |