Function TEST

valdi/test/runtime/ValueMarshallerRegistry_tests.cpp:976–1018

};

TEST(ValueMarshallerRegistry, canMarshallSimpleObject) {
    auto schemaRegistry = makeShared<ValueSchemaRegistry>();
    auto valueMarshallerRegistry = makeShared<TestValueMarshallerRegistry>(schemaRegistry);

    auto schema = ValueSchema::parse("c 'MyObject'{'aString': s, 'aDouble': d}");

    ASSERT_TRUE(schema) << schema.description();

    auto identifier = schemaRegistry->registerSchema(schema.value());

    SimpleExceptionTracker exceptionTracker;
    auto object =
        Value().setMapValue("aString", Value(STRING_LITERAL("Hello world"))).setMapValue("aDouble", Value(42.0));

    auto result = valueMarshallerRegistry->unmarshall(identifier, object, exceptionTracker);

    ASSERT_TRUE(exceptionTracker) << exceptionTracker.extractError().toString();

    auto testObject = result.getTypedRef<TestObject>();
    ASSERT_TRUE(testObject != nullptr);

    ASSERT_EQ(static_cast<size_t>(2), testObject->getPropertiesSize());

    ASSERT_EQ(Value(STRING_LITERAL("Hello world")), testObject->getProperty(0));
    ASSERT_EQ(Value(42.0), testObject->getProperty(1));

    // Now attempt marshalling

    testObject->setProperty(0, Value(STRING_LITERAL("Goodbye")));
    testObject->setProperty(1, Value(90.0));

    auto marshalledValue = valueMarshallerRegistry->marshall(identifier, Value(testObject), exceptionTracker);

    ASSERT_TRUE(exceptionTracker) << exceptionTracker.extractError().toString();

    ASSERT_EQ(Value(ValueTypedObject::make(schema.value().getClassRef(),
                                           {Value(StaticString::makeUTF8("Goodbye")), Value(90.0)})),
              marshalledValue);

    ASSERT_EQ(
        Value().setMapValue("aString", Value(StaticString::makeUTF8("Goodbye"))).setMapValue("aDouble", Value(90.0)),
        Value(marshalledValue.getTypedObject()->toValueMap(true)));
}

TEST(ValueMarshallerRegistry, performsTypeValidationWhileUnmarshalling) {
    auto schemaRegistry = makeShared<ValueSchemaRegistry>();