public void LinkEncoderArrayFromList(double[] value, string expected)
{
var decoded = new List <double>(value);
var encoded = LinkerTester.Encode(Linker.CreateEncoder(new JSONSchema <List <double> >()), decoded);
CollectionAssert.AreEqual(expected, Encoding.UTF8.GetString(encoded));
}
public void LinkEncoderVisibility(BindingFlags bindings, string expected)
{
var decoded = new Visibility();
var encoded = LinkerTester.Encode(Linker.CreateEncoder(new JSONSchema <Visibility>(), bindings), decoded);
Assert.AreEqual(expected, Encoding.UTF8.GetString(encoded));
}
public void RoundTripValueNative <T>(T instance)
{
var schema = this.CreateSchema <T>();
var decoder = Linker.CreateDecoder(schema);
var encoder = Linker.CreateEncoder(schema);
SchemaTester.AssertRoundTrip(decoder, encoder, instance);
}
public void RoundTripValueNullable()
{
var schema = this.CreateSchema <double?>();
var decoder = Linker.CreateDecoder(schema);
var encoder = Linker.CreateEncoder(schema);
SchemaTester.AssertRoundTrip(decoder, encoder, null);
SchemaTester.AssertRoundTrip(decoder, encoder, 42);
}
public void LinkEncoderProperty <T>(T value, string expected)
{
var decoded = new PropertyContainer <T> {
Property = value
};
var encoded = LinkerTester.Encode(Linker.CreateEncoder(new JSONSchema <PropertyContainer <T> >()), decoded);
Assert.AreEqual(expected, Encoding.UTF8.GetString(encoded));
}
public void LinkEncoderRecursive(bool omitNull, string expected)
{
var decoded = new Recursive {
r = new Recursive {
r = new Recursive {
v = 42
}, v = 17
}, v = 3
};
var encoded = LinkerTester.Encode(Linker.CreateEncoder(new JSONSchema <Recursive>(new JSONConfiguration {
OmitNull = omitNull
})), decoded);
Assert.AreEqual(expected, Encoding.UTF8.GetString(encoded));
}
public void RoundTripMixedTypes()
{
var schema = this.CreateSchema <MixedContainer>();
var decoder = Linker.CreateDecoder(schema);
var encoder = Linker.CreateEncoder(schema);
SchemaTester.AssertRoundTrip(decoder, encoder, new MixedContainer
{
floats = new[] { 1.1f, 2.2f, 3.3f },
integer = 17,
option = SomeEnum.B,
pairs = new Dictionary <string, string>
{
{ "a", "aaa" },
{ "b", "bbb" }
},
text = "Hello, World!"
});
}
public void RoundTripNestedValue()
{
var schema = this.CreateSchema <NestedValue>();
var decoder = Linker.CreateDecoder(schema);
var encoder = Linker.CreateEncoder(schema);
SchemaTester.AssertRoundTrip(decoder, encoder, new NestedValue
{
child = new NestedValue
{
child = new NestedValue
{
child = null,
value = 64
},
value = 42
},
value = 17
});
}
public void EncodeFlatStructure()
{
var encoder = Linker.CreateEncoder(new JSONSchema <MyFlatStructure>());
var instance = new MyFlatStructure
{
adipiscing = 64,
amet = "Hello, World!",
consectetur = 255,
elit = 'z',
fermentum = 6553,
hendrerit = -32768,
ipsum = 65464658634633,
lorem = 0,
pulvinar = "I sense a soul in search of answers",
sed = 53.25f,
sit = 1.1
};
CompareNewtonsoft.BenchEncode(encoder, instance, 10000);
}
public void RoundTripNestedArray()
{
var schema = this.CreateSchema <NestedArray>();
var decoder = Linker.CreateDecoder(schema);
var encoder = Linker.CreateEncoder(schema);
SchemaTester.AssertRoundTrip(decoder, encoder, new NestedArray
{
children = new[]
{
new NestedArray
{
children = Array.Empty <NestedArray>(),
value = "a"
},
new NestedArray
{
children = new []
{
new NestedArray
{
children = Array.Empty <NestedArray>(),
value = "b"
},
new NestedArray
{
children = Array.Empty <NestedArray>(),
value = "c"
}
},
value = "d"
},
new NestedArray
{
children = Array.Empty <NestedArray>(),
value = "e"
}
},
value = "f"
});
}
public void EncodeNestedArray()
{
var encoder = Linker.CreateEncoder(new JSONSchema <MyNestedArray>());
var instance = new MyNestedArray
{
children = new[]
{
new MyNestedArray
{
children = null,
value = "a"
},
new MyNestedArray
{
children = new[]
{
new MyNestedArray
{
children = null,
value = "b"
},
new MyNestedArray
{
children = null,
value = "c"
}
},
value = "d"
},
new MyNestedArray
{
children = new MyNestedArray[0],
value = "e"
}
},
value = "f"
};
CompareNewtonsoft.BenchEncode(encoder, instance, 10000);
}
