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>(); }