private static void WriteComplexValue(
bool indented,
string jsonIn,
string expectedIndent,
string expectedMinimal)
{
var buffer = new ArrayBufferWriter <byte>(1024);
byte[] bufferOutput;
var options = new JsonWriterOptions
{
Indented = indented,
};
using (JsonDocument doc = JsonDocument.Parse($" [ {jsonIn} ]", s_options))
{
JsonElement target = doc.RootElement[0];
using var writer = new Utf8JsonWriter(buffer, options);
target.WriteTo(writer);
writer.Flush();
if (indented && s_replaceNewlines)
{
JsonTestHelper.AssertContents(
expectedIndent.Replace(CompiledNewline, Environment.NewLine),
buffer);
}
JsonTestHelper.AssertContents(indented ? expectedIndent : expectedMinimal, buffer);
bufferOutput = buffer.WrittenSpan.ToArray();
}
// After reading the output and writing it again, it should be byte-for-byte identical.
{
string bufferString = Encoding.UTF8.GetString(bufferOutput);
buffer.Clear();
using (JsonDocument doc2 = JsonDocument.Parse(bufferString, s_options))
{
using (var writer = new Utf8JsonWriter(buffer, options))
{
doc2.RootElement.WriteTo(writer);
}
}
Assert.True(buffer.WrittenSpan.SequenceEqual(bufferOutput));
}
}
public void Setup()
{
_arrayBufferWriter = new ArrayBufferWriter <byte>();
_stringArrayValues = new string[DataSize];
_stringArrayValuesUtf8 = new byte[DataSize][];
var random = new Random(42);
for (int i = 0; i < DataSize; i++)
{
_stringArrayValues[i] = GetString(random, 5, 100, Escaped);
_stringArrayValuesUtf8[i] = Encoding.UTF8.GetBytes(_stringArrayValues[i]);
}
}
public static void WriteWithRelaxedEscaper(bool indented, string jsonIn, string jsonOut, bool matchesRelaxedEscaping)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = JsonDocument.Parse($" [ {jsonIn} ]", s_options))
{
JsonElement target = doc.RootElement[0];
{
var options = new JsonWriterOptions
{
Indented = indented,
};
using var writer = new Utf8JsonWriter(buffer, options);
target.WriteTo(writer);
writer.Flush();
if (matchesRelaxedEscaping)
{
JsonTestHelper.AssertContents(jsonOut, buffer);
}
else
{
JsonTestHelper.AssertContentsNotEqual(jsonOut, buffer);
}
}
buffer.Clear();
{
var options = new JsonWriterOptions
{
Indented = indented,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
};
using var writer = new Utf8JsonWriter(buffer, options);
target.WriteTo(writer);
writer.Flush();
JsonTestHelper.AssertContents(jsonOut, buffer);
}
}
}
public void WriteValueSurrogatesEscapeString()
{
string unicodeString = "\uD800\uDC00\uD803\uDE6D \uD834\uDD1E\uDBFF\uDFFF";
string expectedStr = "\"\\uD800\\uDC00\\uD803\\uDE6D \\uD834\\uDD1E\\uDBFF\\uDFFF\"";
string json = $"\"{unicodeString}\"";
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = PrepareDocument(json))
{
using (var writer = new Utf8JsonWriter(buffer))
{
WriteSingleValue(doc, writer);
}
JsonTestHelper.AssertContents(expectedStr, buffer);
}
}
public void WriteWithRelaxedEscaper(bool indented, string jsonIn, string jsonOut, bool matchesRelaxedEscaping)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = PrepareDocument(jsonIn))
{
{
var options = new JsonWriterOptions
{
Indented = indented,
};
using (var writer = new Utf8JsonWriter(buffer, options))
{
WriteSingleValue(doc, writer);
}
if (matchesRelaxedEscaping)
{
JsonTestHelper.AssertContents(jsonOut, buffer);
}
else
{
JsonTestHelper.AssertContentsNotEqual(jsonOut, buffer);
}
}
buffer.Clear();
{
var options = new JsonWriterOptions
{
Indented = indented,
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
};
using (var writer = new Utf8JsonWriter(buffer, options))
{
WriteSingleValue(doc, writer);
}
JsonTestHelper.AssertContents(jsonOut, buffer);
}
}
}
public static void WriteValueInsideObject(bool skipValidation)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (var doc = JsonDocument.Parse("[ null, false, true, \"hi\", 5, {}, [] ]", s_readerOptions))
{
JsonElement root = doc.RootElement;
var options = new JsonWriterOptions
{
SkipValidation = skipValidation,
};
var writer = new Utf8JsonWriter(buffer, options);
writer.WriteStartObject();
if (skipValidation)
{
foreach (JsonElement val in root.EnumerateArray())
{
val.WriteAsValue(writer);
}
writer.WriteEndObject();
writer.Flush();
AssertContents(
"{null,false,true,\"hi\",5,{},[]}",
buffer);
}
else
{
foreach (JsonElement val in root.EnumerateArray())
{
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteAsValue(w));
}
writer.WriteEndObject();
writer.Flush();
AssertContents("{}", buffer);
}
}
}
public static void WriteSimpleObject()
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = JsonDocument.Parse("{\"First\":1, \"Number\":1e400}"))
{
using var writer = new Utf8JsonWriter(buffer);
writer.WriteStartObject();
foreach (JsonProperty prop in doc.RootElement.EnumerateObject())
{
prop.WriteTo(writer);
}
writer.WriteEndObject();
writer.Flush();
AssertContents("{\"First\":1,\"Number\":1e400}", buffer);
}
}
public static void WriteValueSurrogatesEscapeString()
{
string unicodeString = "\uD800\uDC00\uD803\uDE6D \uD834\uDD1E\uDBFF\uDFFF";
string json = $"[\"{unicodeString}\"]";
var buffer = new ArrayBufferWriter <byte>(1024);
string expectedStr = GetEscapedExpectedString(unicodeString, StringEscapeHandling.EscapeNonAscii);
using (JsonDocument doc = JsonDocument.Parse(json, s_options))
{
JsonElement target = doc.RootElement[0];
using (var writer = new Utf8JsonWriter(buffer))
{
target.WriteTo(writer);
writer.Flush();
}
JsonTestHelper.AssertContents(expectedStr, buffer);
}
}
private void WriteSimpleValue(bool indented, string jsonIn, string jsonOut = null)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = PrepareDocument(jsonIn))
{
var options = new JsonWriterOptions
{
Indented = indented,
};
using (var writer = new Utf8JsonWriter(buffer, options))
{
WriteSingleValue(doc, writer);
}
JsonTestHelper.AssertContents(jsonOut ?? jsonIn, buffer);
}
}
private void WriteComplexValue(
bool indented,
string jsonIn,
string expectedIndent,
string expectedMinimal)
{
var buffer = new ArrayBufferWriter <byte>(1024);
byte[] bufferOutput;
var options = new JsonWriterOptions
{
Indented = indented
};
using (JsonDocument doc = PrepareDocument(jsonIn))
{
using (var writer = new Utf8JsonWriter(buffer, options))
{
WriteSingleValue(doc, writer);
}
JsonTestHelper.AssertContents(indented ? expectedIndent : expectedMinimal, buffer);
bufferOutput = buffer.WrittenSpan.ToArray();
}
// After reading the output and writing it again, it should be byte-for-byte identical.
{
string bufferString = Encoding.UTF8.GetString(bufferOutput);
buffer.Clear();
using (JsonDocument doc2 = PrepareDocument(bufferString))
{
using (var writer = new Utf8JsonWriter(buffer, options))
{
WriteSingleValue(doc2, writer);
}
}
Assert.True(buffer.WrittenSpan.SequenceEqual(bufferOutput));
}
}
private static void WriteSimpleValue(bool indented, string jsonIn, string jsonOut = null)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = JsonDocument.Parse($" [ {jsonIn} ]", s_readerOptions))
{
JsonElement target = doc.RootElement[0];
var options = new JsonWriterOptions
{
Indented = indented,
};
var writer = new Utf8JsonWriter(buffer, options);
target.WriteAsValue(writer);
writer.Flush();
AssertContents(jsonOut ?? jsonIn, buffer);
}
}
public void Setup()
{
_arrayBufferWriter = new ArrayBufferWriter <byte>();
var random = new Random(42);
_numberArrayValues = new double[DataSize];
int halfSize = DataSize / 2;
for (int i = 0; i < halfSize; i++)
{
double value = NextDouble(random, double.MinValue / 10, double.MaxValue / 10);
_numberArrayValues[i] = value;
}
for (int i = 0; i < halfSize; i++)
{
double value = NextDouble(random, 1_000_000, -1_000_000);
_numberArrayValues[i + halfSize] = value;
}
}
private void WriteComplexValue(
bool indented,
string jsonIn,
string expectedIndent,
string expectedMinimal)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (JsonDocument doc = PrepareDocument(jsonIn))
{
var options = new JsonWriterOptions
{
Indented = indented
};
using (var writer = new Utf8JsonWriter(buffer, options))
{
WriteSingleValue(doc, writer);
}
JsonTestHelper.AssertContents(indented ? expectedIndent : expectedMinimal, buffer);
}
}
public void Setup()
{
_arrayBufferWriter = new ArrayBufferWriter <byte>();
var random = new Random(42);
_numberArrayValues = new int[DataSize];
for (int i = 0; i < DataSize; i++)
{
_numberArrayValues[i] = random.Next(-10000, 10000);
}
_extraArrayUtf8 = Encoding.UTF8.GetBytes("ExtraArray");
_firstUtf8 = Encoding.UTF8.GetBytes("first");
_lastUtf8 = Encoding.UTF8.GetBytes("last");
_ageUtf8 = Encoding.UTF8.GetBytes("age");
_phoneNumbersUtf8 = Encoding.UTF8.GetBytes("phoneNumbers");
_addressUtf8 = Encoding.UTF8.GetBytes("address");
_streetUtf8 = Encoding.UTF8.GetBytes("street");
_cityUtf8 = Encoding.UTF8.GetBytes("city");
_zipUtf8 = Encoding.UTF8.GetBytes("zip");
}
private static void WritePropertyValue(
bool indented,
string propertyName,
string jsonIn,
string expectedIndent,
string expectedMinimal)
{
var buffer = new ArrayBufferWriter <byte>(1024);
string temp = $" [ {jsonIn} ]";
using (JsonDocument doc = JsonDocument.Parse(temp, s_options))
{
JsonElement target = doc.RootElement[0];
var options = new JsonWriterOptions
{
Indented = indented,
};
var writer = new Utf8JsonWriter(buffer, options);
writer.WriteStartObject();
writer.WritePropertyName(propertyName);
target.WriteTo(writer);
writer.WriteEndObject();
writer.Flush();
if (indented && s_replaceNewlines)
{
AssertContents(
expectedIndent.Replace(CompiledNewline, Environment.NewLine),
buffer);
}
AssertContents(indented ? expectedIndent : expectedMinimal, buffer);
}
}
public void WriteIncredibleDepth()
{
const int TargetDepth = 500;
JsonDocumentOptions optionsCopy = s_options;
optionsCopy.MaxDepth = TargetDepth + 1;
const int SpacesPre = 12;
const int SpacesSplit = 85;
const int SpacesPost = 4;
byte[] jsonIn = new byte[SpacesPre + TargetDepth + SpacesSplit + TargetDepth + SpacesPost];
jsonIn.AsSpan(0, SpacesPre).Fill((byte)' ');
Span <byte> openBrackets = jsonIn.AsSpan(SpacesPre, TargetDepth);
openBrackets.Fill((byte)'[');
jsonIn.AsSpan(SpacesPre + TargetDepth, SpacesSplit).Fill((byte)' ');
Span <byte> closeBrackets = jsonIn.AsSpan(SpacesPre + TargetDepth + SpacesSplit, TargetDepth);
closeBrackets.Fill((byte)']');
jsonIn.AsSpan(SpacesPre + TargetDepth + SpacesSplit + TargetDepth).Fill((byte)' ');
var buffer = new ArrayBufferWriter <byte>(jsonIn.Length);
using (JsonDocument doc = JsonDocument.Parse(jsonIn, optionsCopy))
{
using (var writer = new Utf8JsonWriter(buffer))
{
WriteDocument(doc, writer);
}
ReadOnlySpan <byte> formatted = buffer.WrittenSpan;
Assert.Equal(TargetDepth + TargetDepth, formatted.Length);
Assert.True(formatted.Slice(0, TargetDepth).SequenceEqual(openBrackets), "OpenBrackets match");
Assert.True(formatted.Slice(TargetDepth).SequenceEqual(closeBrackets), "CloseBrackets match");
}
}
public static void WriteIncredibleDepth()
{
const int TargetDepth = 500;
JsonReaderOptions optionsCopy = s_readerOptions;
optionsCopy.MaxDepth = TargetDepth + 1;
const int SpacesPre = 12;
const int SpacesSplit = 85;
const int SpacesPost = 4;
byte[] jsonIn = new byte[SpacesPre + TargetDepth + SpacesSplit + TargetDepth + SpacesPost];
jsonIn.AsSpan(0, SpacesPre).Fill((byte)' ');
Span <byte> openBrackets = jsonIn.AsSpan(SpacesPre, TargetDepth);
openBrackets.Fill((byte)'[');
jsonIn.AsSpan(SpacesPre + TargetDepth, SpacesSplit).Fill((byte)' ');
Span <byte> closeBrackets = jsonIn.AsSpan(SpacesPre + TargetDepth + SpacesSplit, TargetDepth);
closeBrackets.Fill((byte)']');
jsonIn.AsSpan(SpacesPre + TargetDepth + SpacesSplit + TargetDepth).Fill((byte)' ');
using (ArrayBufferWriter buffer = new ArrayBufferWriter(jsonIn.Length))
using (JsonDocument doc = JsonDocument.Parse(jsonIn, optionsCopy))
{
var writer = new Utf8JsonWriter(buffer);
doc.RootElement.WriteAsValue(ref writer);
writer.Flush();
ArraySegment <byte> formattedSegment = buffer.Formatted;
ReadOnlySpan <byte> formatted = formattedSegment;
Assert.Equal(TargetDepth + TargetDepth, formatted.Length);
Assert.True(formatted.Slice(0, TargetDepth).SequenceEqual(openBrackets), "OpenBrackets match");
Assert.True(formatted.Slice(TargetDepth).SequenceEqual(closeBrackets), "CloseBrackets match");
}
}
public void Setup()
{
_arrayBufferWriter = new ArrayBufferWriter <byte>();
var random = new Random(42);
_propertyNames = new string[Depth];
_propertyNamesUtf8 = new byte[Depth][];
_numberArrayValues = new int[DataSize];
_stringArrayValues = new string[DataSize];
for (int i = 0; i < Depth; i++)
{
_propertyNames[i] = "abcde" + i.ToString();
_propertyNamesUtf8[i] = Encoding.UTF8.GetBytes(_propertyNames[i]);
}
for (int i = 0; i < DataSize; i++)
{
int value = random.Next(-10000, 10000);
_numberArrayValues[i] = value;
_stringArrayValues[i] = value.ToString();
}
}
public static void WritePropertyOutsideObject(bool skipValidation)
{
var buffer = new ArrayBufferWriter <byte>(1024);
using (var doc = JsonDocument.Parse("[ null, false, true, \"hi\", 5, {}, [] ]", s_options))
{
JsonElement root = doc.RootElement;
var options = new JsonWriterOptions
{
SkipValidation = skipValidation,
};
const string CharLabel = "char";
byte[] byteUtf8 = Encoding.UTF8.GetBytes("byte");
var writer = new Utf8JsonWriter(buffer, options);
if (skipValidation)
{
foreach (JsonElement val in root.EnumerateArray())
{
val.WriteProperty(CharLabel, writer);
val.WriteProperty(CharLabel.AsSpan(), writer);
val.WriteProperty(byteUtf8, writer);
val.WriteProperty(JsonEncodedText.Encode(CharLabel), writer);
}
writer.Flush();
AssertContents(
"\"char\":null,\"char\":null,\"byte\":null,\"char\":null," +
"\"char\":false,\"char\":false,\"byte\":false,\"char\":false," +
"\"char\":true,\"char\":true,\"byte\":true,\"char\":true," +
"\"char\":\"hi\",\"char\":\"hi\",\"byte\":\"hi\",\"char\":\"hi\"," +
"\"char\":5,\"char\":5,\"byte\":5,\"char\":5," +
"\"char\":{},\"char\":{},\"byte\":{},\"char\":{}," +
"\"char\":[],\"char\":[],\"byte\":[],\"char\":[]",
buffer);
}
else
{
foreach (JsonElement val in root.EnumerateArray())
{
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteProperty(CharLabel, w));
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteProperty(CharLabel.AsSpan(), w));
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteProperty(byteUtf8, w));
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteProperty(JsonEncodedText.Encode(CharLabel), w));
}
writer.Flush();
AssertContents("", buffer);
}
}
}
public void Setup()
{
_arrayBufferWriter = new ArrayBufferWriter <byte>();
}
