private static void TestReadTokenWithExtra(ReadOnlySequence <byte> sequence, JsonCommentHandling commentHandling, bool isFinalBlock, bool commentsAppended = false)
{
JsonReaderState state = new JsonReaderState(options: new JsonReaderOptions {
CommentHandling = commentHandling
});
Utf8JsonReader reader = new Utf8JsonReader(sequence, isFinalBlock, state);
if (commentsAppended && commentHandling == JsonCommentHandling.Allow)
{
Assert.True(reader.Read());
Assert.Equal(JsonTokenType.Comment, reader.TokenType);
Assert.True(reader.Read());
Assert.Equal(JsonTokenType.Comment, reader.TokenType);
}
Assert.True(reader.Read());
if (reader.TokenType == JsonTokenType.StartArray || reader.TokenType == JsonTokenType.StartObject)
{
Assert.True(reader.Read());
Assert.Contains(reader.TokenType, new[] { JsonTokenType.EndArray, JsonTokenType.EndObject });
}
JsonTestHelper.AssertThrows <JsonReaderException>(reader, (jsonReader) =>
{
jsonReader.Read();
if (commentHandling == JsonCommentHandling.Allow && jsonReader.TokenType == JsonTokenType.Comment)
{
jsonReader.Read();
}
});
}
public static void WritePropertyOutsideObject(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,
};
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.WriteAsProperty(CharLabel, writer);
val.WriteAsProperty(CharLabel.AsSpan(), writer);
val.WriteAsProperty(byteUtf8, writer);
}
writer.Flush();
AssertContents(
"\"char\":null,\"char\":null,\"byte\":null," +
"\"char\":false,\"char\":false,\"byte\":false," +
"\"char\":true,\"char\":true,\"byte\":true," +
"\"char\":\"hi\",\"char\":\"hi\",\"byte\":\"hi\"," +
"\"char\":5,\"char\":5,\"byte\":5," +
"\"char\":{},\"char\":{},\"byte\":{}," +
"\"char\":[],\"char\":[],\"byte\":[]",
buffer);
}
else
{
foreach (JsonElement val in root.EnumerateArray())
{
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteAsProperty(CharLabel, w));
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteAsProperty(CharLabel.AsSpan(), w));
JsonTestHelper.AssertThrows <InvalidOperationException>(
ref writer,
(ref Utf8JsonWriter w) => val.WriteAsProperty(byteUtf8, w));
}
writer.Flush();
AssertContents("", buffer);
}
}
}
public static void TestingStringsInvalidConversionToGuid(string testString)
{
byte[] dataUtf8 = Encoding.UTF8.GetBytes($"\"{testString}\"");
var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default);
Assert.True(json.Read(), "Read string value");
Assert.Equal(JsonTokenType.String, json.TokenType);
Assert.False(json.TryGetGuid(out Guid actual));
Assert.Equal(Guid.Empty, actual);
JsonTestHelper.AssertThrows <FormatException>(json, (jsonReader) => jsonReader.GetGuid());
}
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 InvalidConversion()
{
string jsonString = "[\"stringValue\", true, 1234]";
byte[] dataUtf8 = Encoding.UTF8.GetBytes(jsonString);
var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default);
while (json.Read())
{
if (json.TokenType != JsonTokenType.String)
{
try
{
string value = json.GetString();
Assert.True(false, "Expected GetString to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
DateTime value = json.GetDateTime();
Assert.True(false, "Expected GetDateTime to throw InvalidOperationException due to mismatched token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetDateTime(out DateTime value);
Assert.True(false, "Expected TryGetDateTime to throw InvalidOperationException due to mismatched token type.");
}
catch (InvalidOperationException)
{ }
try
{
DateTimeOffset value = json.GetDateTimeOffset();
Assert.True(false, "Expected GetDateTimeOffset to throw InvalidOperationException due to mismatched token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetDateTimeOffset(out DateTimeOffset value);
Assert.True(false, "Expected TryGetDateTimeOffset to throw InvalidOperationException due to mismatched token type.");
}
catch (InvalidOperationException)
{ }
JsonTestHelper.AssertThrows <InvalidOperationException>(json, (jsonReader) => jsonReader.GetGuid());
JsonTestHelper.AssertThrows <InvalidOperationException>(json, (jsonReader) => jsonReader.TryGetGuid(out _));
}
if (json.TokenType != JsonTokenType.True && json.TokenType != JsonTokenType.False)
{
try
{
bool value = json.GetBoolean();
Assert.True(false, "Expected GetBoolean to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
}
if (json.TokenType != JsonTokenType.Number)
{
try
{
json.TryGetInt32(out int value);
Assert.True(false, "Expected TryGetInt32 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetInt32();
Assert.True(false, "Expected GetInt32 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetInt64(out long value);
Assert.True(false, "Expected TryGetInt64 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetInt64();
Assert.True(false, "Expected GetInt64 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetUInt32(out uint value);
Assert.True(false, "Expected TryGetUInt32 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetUInt32();
Assert.True(false, "Expected GetUInt32 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetUInt64(out ulong value);
Assert.True(false, "Expected TryGetUInt64 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetUInt64();
Assert.True(false, "Expected GetUInt64 to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetSingle(out float value);
Assert.True(false, "Expected TryGetSingle to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetSingle();
Assert.True(false, "Expected GetSingle to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetDouble(out double value);
Assert.True(false, "Expected TryGetDouble to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetDouble();
Assert.True(false, "Expected GetDouble to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.TryGetDecimal(out decimal value);
Assert.True(false, "Expected TryGetDecimal to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
try
{
json.GetDecimal();
Assert.True(false, "Expected GetDecimal to throw InvalidOperationException due to mismatch token type.");
}
catch (InvalidOperationException)
{ }
}
}
Assert.Equal(dataUtf8.Length, json.BytesConsumed);
Assert.Equal(json.BytesConsumed, json.CurrentState.BytesConsumed);
}