public void Test_WriteMultipleEncodeablesWithFieldNames()
{
var expected = "{\"bar_1\":{\"Foo\":\"bar_1\"},\"bar_2\":{\"Foo\":\"bar_2\"},\"bar_3\":{\"Foo\":\"bar_3\"}}";
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
var encodeables = new List <FooBarEncodeable> {
new FooBarEncodeable(), new FooBarEncodeable(), new FooBarEncodeable()
};
try
{
var encoder = new JsonEncoder(Context, true, null, false);
foreach (var encodeable in encodeables)
{
encoder.WriteEncodeable(encodeable.Foo, encodeable, typeof(FooBarEncodeable));
}
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
finally
{
encodeables.ForEach(e => e.Dispose());
}
}
/// <summary>
/// Encode DataSet message header
/// </summary>
private void EncodeDataSetMessageHeader(JsonEncoder encoder)
{
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.DataSetWriterId) != 0)
{
encoder.WriteString(nameof(DataSetWriterId), DataSetWriterId.ToString());
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.SequenceNumber) != 0)
{
encoder.WriteUInt32(nameof(SequenceNumber), SequenceNumber);
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.MetaDataVersion) != 0)
{
encoder.WriteEncodeable(nameof(MetaDataVersion), MetaDataVersion, typeof(ConfigurationVersionDataType));
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.Timestamp) != 0)
{
encoder.WriteDateTime(nameof(Timestamp), Timestamp);
}
if ((DataSetMessageContentMask & JsonDataSetMessageContentMask.Status) != 0)
{
encoder.WriteStatusCode(nameof(Status), Status);
}
}
/// <summary>
/// Encodes the object in the specified stream.
/// </summary>
/// <param name="messageContext">The context.</param>
/// <param name="stream">The stream to use.</param>
public override void Encode(IServiceMessageContext messageContext, Stream stream)
{
bool topLevelIsArray = !HasNetworkMessageHeader && !HasSingleDataSetMessage && !IsMetaDataMessage;
using (JsonEncoder encoder = new JsonEncoder(messageContext, true, topLevelIsArray, stream))
{
if (IsMetaDataMessage)
{
EncodeNetworkMessageHeader(encoder);
encoder.WriteEncodeable(kFieldMetaData, m_metadata, null);
return;
}
// handle no header
if (HasNetworkMessageHeader)
{
Encode(encoder);
}
else if (DataSetMessages != null && DataSetMessages.Count > 0)
{
if (HasSingleDataSetMessage)
{
// encode single dataset message
JsonDataSetMessage jsonDataSetMessage = DataSetMessages[0] as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
if (!jsonDataSetMessage.HasDataSetMessageHeader)
{
// If the NetworkMessageHeader and the DataSetMessageHeader bits are not set
// and SingleDataSetMessage bit is set, the NetworkMessage is a JSON object
// containing the set of name/value pairs defined for a single DataSet.
jsonDataSetMessage.EncodePayload(encoder, false);
}
else
{
// If the SingleDataSetMessage bit of the NetworkMessageContentMask is set,
// the content of the Messages field is a JSON object containing a single DataSetMessage.
jsonDataSetMessage.Encode(encoder);
}
}
}
else
{
// If the NetworkMessageHeader bit of the NetworkMessageContentMask is not set,
// the NetworkMessage is the contents of the Messages field (e.g. a JSON array of DataSetMessages).
foreach (var message in DataSetMessages)
{
JsonDataSetMessage jsonDataSetMessage = message as JsonDataSetMessage;
if (jsonDataSetMessage != null)
{
jsonDataSetMessage.Encode(encoder);
}
}
}
}
}
}
public void Test_WriteMultipleEncodeablesWithoutFieldNames(bool topLevelIsArray, string expected)
{
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
var encodeables = new List <FooBarEncodeable> {
new FooBarEncodeable(), new FooBarEncodeable(), new FooBarEncodeable()
};
try
{
var encoder = new JsonEncoder(Context, true, null, topLevelIsArray);
foreach (var encodeable in encodeables)
{
encoder.WriteEncodeable(null, encodeable, typeof(FooBarEncodeable));
}
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
finally
{
encodeables.ForEach(e => e.Dispose());
}
}
public void Test_WriteSingleEncodeableWithName()
{
var expected = "{\"bar_1\":{\"Foo\":\"bar_1\"}}";
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
using (var encodeable = new FooBarEncodeable())
{
using (var encoder = new JsonEncoder(Context, true, false))
{
encoder.WriteEncodeable(encodeable.Foo, encodeable, typeof(FooBarEncodeable));
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
}
}
public void Test_WriteMultipleEncodeableWithoutName_Expect_Exception()
{
// invalid JSON
// "{\"Foo\":\"bar_1\"},{\"Foo\":\"bar_2\"},{\"Foo\":\"bar_3\"}"
// "{{\"Foo\":\"bar_1\"},{\"Foo\":\"bar_2\"},{\"Foo\":\"bar_3\"}}"
using (var encodeable = new FooBarEncodeable())
{
var encoder = new JsonEncoder(Context, true, null, false);
Assert.Throws <ServiceResultException>(() => {
encoder.WriteEncodeable(null, encodeable, typeof(FooBarEncodeable));
encoder.WriteEncodeable(null, encodeable, typeof(FooBarEncodeable));
encoder.WriteEncodeable(null, encodeable, typeof(FooBarEncodeable));
}
);
}
}
public void Test_WriteSingleEncodeableWithNameAndArrayAsTopLevel_Expect_Exception()
{
using (var encodeable = new FooBarEncodeable())
{
var encoder = new JsonEncoder(Context, true, null, true);
Assert.Throws <ServiceResultException>(() => encoder.WriteEncodeable(encodeable.Foo, encodeable, typeof(FooBarEncodeable)));
}
}
public void TestFieldValueEscapedEncodeable(string fieldname, string foo, string expected)
{
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
using (var encodeable = new FooBarEncodeable(fieldname, foo))
{
var encoder = new JsonEncoder(Context, true);
encoder.WriteEncodeable(encodeable.FieldName, encodeable, typeof(FooBarEncodeable));
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
}
public void Test_WriteSingleEncodeableWithoutName(bool topLevelIsArray, string expected)
{
TestContext.Out.WriteLine("Expected:");
_ = PrettifyAndValidateJson(expected);
using (var encodeable = new FooBarEncodeable())
{
var encoder = new JsonEncoder(Context, true, null, topLevelIsArray);
encoder.WriteEncodeable(null, encodeable, typeof(FooBarEncodeable));
var encoded = encoder.CloseAndReturnText();
TestContext.Out.WriteLine("Encoded:");
TestContext.Out.WriteLine(encoded);
TestContext.Out.WriteLine("Formatted Encoded:");
_ = PrettifyAndValidateJson(encoded);
Assert.That(encoded, Is.EqualTo(expected));
}
}