Asynchronous methods in readers and writers. (#1122)
Contributes to #650
This commit is contained in:
committed by
James Newton-King
parent
211b3b0db2
commit
f663060005
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,541 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
#if !(NET20 || NET35 || NET40 || PORTABLE40)
|
||||
|
||||
using System;
|
||||
#if !(NET20 || NET35 || PORTABLE) || NETSTANDARD1_1
|
||||
using System.Numerics;
|
||||
#endif
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
#if DNXCORE50
|
||||
using Xunit;
|
||||
using Test = Xunit.FactAttribute;
|
||||
using Assert = Newtonsoft.Json.Tests.XUnitAssert;
|
||||
#else
|
||||
using NUnit.Framework;
|
||||
#endif
|
||||
using Newtonsoft.Json.Bson;
|
||||
using System.IO;
|
||||
using System.Globalization;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.Bson
|
||||
{
|
||||
[TestFixture]
|
||||
public class BsonWriterAsyncTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public async Task CloseOutputAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
Assert.IsTrue(ms.CanRead);
|
||||
await writer.CloseAsync();
|
||||
Assert.IsFalse(ms.CanRead);
|
||||
|
||||
ms = new MemoryStream();
|
||||
writer = new BsonWriter(ms) { CloseOutput = false };
|
||||
|
||||
Assert.IsTrue(ms.CanRead);
|
||||
await writer.CloseAsync();
|
||||
Assert.IsTrue(ms.CanRead);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteSingleObjectAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("Blah");
|
||||
await writer.WriteValueAsync(1);
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("0F-00-00-00-10-42-6C-61-68-00-01-00-00-00-00", bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteValuesAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync(long.MaxValue);
|
||||
await writer.WriteValueAsync((ulong)long.MaxValue);
|
||||
await writer.WriteValueAsync(int.MaxValue);
|
||||
await writer.WriteValueAsync((uint)int.MaxValue);
|
||||
await writer.WriteValueAsync(byte.MaxValue);
|
||||
await writer.WriteValueAsync(sbyte.MaxValue);
|
||||
await writer.WriteValueAsync('a');
|
||||
await writer.WriteValueAsync(decimal.MaxValue);
|
||||
await writer.WriteValueAsync(double.MaxValue);
|
||||
await writer.WriteValueAsync(float.MaxValue);
|
||||
await writer.WriteValueAsync(true);
|
||||
await writer.WriteValueAsync(new byte[] { 0, 1, 2, 3, 4 });
|
||||
await writer.WriteValueAsync(new DateTimeOffset(2000, 12, 29, 12, 30, 0, TimeSpan.Zero));
|
||||
await writer.WriteValueAsync(new DateTime(2000, 12, 29, 12, 30, 0, DateTimeKind.Utc));
|
||||
await writer.WriteEndAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("8C-00-00-00-12-30-00-FF-FF-FF-FF-FF-FF-FF-7F-12-31-00-FF-FF-FF-FF-FF-FF-FF-7F-10-32-00-FF-FF-FF-7F-10-33-00-FF-FF-FF-7F-10-34-00-FF-00-00-00-10-35-00-7F-00-00-00-02-36-00-02-00-00-00-61-00-01-37-00-00-00-00-00-00-00-F0-45-01-38-00-FF-FF-FF-FF-FF-FF-EF-7F-01-39-00-00-00-00-E0-FF-FF-EF-47-08-31-30-00-01-05-31-31-00-05-00-00-00-00-00-01-02-03-04-09-31-32-00-40-C5-E2-BA-E3-00-00-00-09-31-33-00-40-C5-E2-BA-E3-00-00-00-00", bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteDoubleAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync(99.99d);
|
||||
await writer.WriteEndAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("10-00-00-00-01-30-00-8F-C2-F5-28-5C-FF-58-40-00", bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteGuidAsync()
|
||||
{
|
||||
Guid g = new Guid("D821EED7-4B5C-43C9-8AC2-6928E579B705");
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync(g);
|
||||
await writer.WriteEndAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("1D-00-00-00-05-30-00-10-00-00-00-04-D7-EE-21-D8-5C-4B-C9-43-8A-C2-69-28-E5-79-B7-05-00", bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteArrayBsonFromSiteAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync("a");
|
||||
await writer.WriteValueAsync("b");
|
||||
await writer.WriteValueAsync("c");
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
await writer.FlushAsync();
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
string expected = "20-00-00-00-02-30-00-02-00-00-00-61-00-02-31-00-02-00-00-00-62-00-02-32-00-02-00-00-00-63-00-00";
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteBytesAsync()
|
||||
{
|
||||
byte[] data = Encoding.UTF8.GetBytes("Hello world!");
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync("a");
|
||||
await writer.WriteValueAsync("b");
|
||||
await writer.WriteValueAsync(data);
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
await writer.FlushAsync();
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
string expected = "2B-00-00-00-02-30-00-02-00-00-00-61-00-02-31-00-02-00-00-00-62-00-05-32-00-0C-00-00-00-00-48-65-6C-6C-6F-20-77-6F-72-6C-64-21-00";
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
|
||||
BsonReader reader = new BsonReader(new MemoryStream(ms.ToArray()));
|
||||
reader.ReadRootValueAsArray = true;
|
||||
await reader.ReadAsync();
|
||||
await reader.ReadAsync();
|
||||
await reader.ReadAsync();
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
|
||||
CollectionAssert.AreEquivalent(data, (byte[])reader.Value);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteNestedArrayAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
await writer.WriteStartObjectAsync();
|
||||
|
||||
await writer.WritePropertyNameAsync("_id");
|
||||
await writer.WriteValueAsync(HexToBytes("4A-78-93-79-17-22-00-00-00-00-61-CF"));
|
||||
|
||||
await writer.WritePropertyNameAsync("a");
|
||||
await writer.WriteStartArrayAsync();
|
||||
for (int i = 1; i <= 8; i++)
|
||||
{
|
||||
double value = (i != 5)
|
||||
? Convert.ToDouble(i)
|
||||
: 5.78960446186581E+77d;
|
||||
|
||||
await writer.WriteValueAsync(value);
|
||||
}
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
await writer.WritePropertyNameAsync("b");
|
||||
await writer.WriteValueAsync("test");
|
||||
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
await writer.FlushAsync();
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
string expected = "87-00-00-00-05-5F-69-64-00-0C-00-00-00-00-4A-78-93-79-17-22-00-00-00-00-61-CF-04-61-00-5D-00-00-00-01-30-00-00-00-00-00-00-00-F0-3F-01-31-00-00-00-00-00-00-00-00-40-01-32-00-00-00-00-00-00-00-08-40-01-33-00-00-00-00-00-00-00-10-40-01-34-00-00-00-00-00-00-00-14-50-01-35-00-00-00-00-00-00-00-18-40-01-36-00-00-00-00-00-00-00-1C-40-01-37-00-00-00-00-00-00-00-20-40-00-02-62-00-05-00-00-00-74-65-73-74-00-00";
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
|
||||
Assert.AreEqual(expected, bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteLargeStringsAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
StringBuilder largeStringBuilder = new StringBuilder();
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
largeStringBuilder.Append("-");
|
||||
}
|
||||
|
||||
largeStringBuilder.Append(i.ToString(CultureInfo.InvariantCulture));
|
||||
}
|
||||
string largeString = largeStringBuilder.ToString();
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync(largeString);
|
||||
await writer.WriteValueAsync(largeString);
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("4E-02-00-00-02-30-2D-31-2D-32-2D-33-2D-34-2D-35-2D-36-2D-37-2D-38-2D-39-2D-31-30-2D-31-31-2D-31-32-2D-31-33-2D-31-34-2D-31-35-2D-31-36-2D-31-37-2D-31-38-2D-31-39-2D-32-30-2D-32-31-2D-32-32-2D-32-33-2D-32-34-2D-32-35-2D-32-36-2D-32-37-2D-32-38-2D-32-39-2D-33-30-2D-33-31-2D-33-32-2D-33-33-2D-33-34-2D-33-35-2D-33-36-2D-33-37-2D-33-38-2D-33-39-2D-34-30-2D-34-31-2D-34-32-2D-34-33-2D-34-34-2D-34-35-2D-34-36-2D-34-37-2D-34-38-2D-34-39-2D-35-30-2D-35-31-2D-35-32-2D-35-33-2D-35-34-2D-35-35-2D-35-36-2D-35-37-2D-35-38-2D-35-39-2D-36-30-2D-36-31-2D-36-32-2D-36-33-2D-36-34-2D-36-35-2D-36-36-2D-36-37-2D-36-38-2D-36-39-2D-37-30-2D-37-31-2D-37-32-2D-37-33-2D-37-34-2D-37-35-2D-37-36-2D-37-37-2D-37-38-2D-37-39-2D-38-30-2D-38-31-2D-38-32-2D-38-33-2D-38-34-2D-38-35-2D-38-36-2D-38-37-2D-38-38-2D-38-39-2D-39-30-2D-39-31-2D-39-32-2D-39-33-2D-39-34-2D-39-35-2D-39-36-2D-39-37-2D-39-38-2D-39-39-00-22-01-00-00-30-2D-31-2D-32-2D-33-2D-34-2D-35-2D-36-2D-37-2D-38-2D-39-2D-31-30-2D-31-31-2D-31-32-2D-31-33-2D-31-34-2D-31-35-2D-31-36-2D-31-37-2D-31-38-2D-31-39-2D-32-30-2D-32-31-2D-32-32-2D-32-33-2D-32-34-2D-32-35-2D-32-36-2D-32-37-2D-32-38-2D-32-39-2D-33-30-2D-33-31-2D-33-32-2D-33-33-2D-33-34-2D-33-35-2D-33-36-2D-33-37-2D-33-38-2D-33-39-2D-34-30-2D-34-31-2D-34-32-2D-34-33-2D-34-34-2D-34-35-2D-34-36-2D-34-37-2D-34-38-2D-34-39-2D-35-30-2D-35-31-2D-35-32-2D-35-33-2D-35-34-2D-35-35-2D-35-36-2D-35-37-2D-35-38-2D-35-39-2D-36-30-2D-36-31-2D-36-32-2D-36-33-2D-36-34-2D-36-35-2D-36-36-2D-36-37-2D-36-38-2D-36-39-2D-37-30-2D-37-31-2D-37-32-2D-37-33-2D-37-34-2D-37-35-2D-37-36-2D-37-37-2D-37-38-2D-37-39-2D-38-30-2D-38-31-2D-38-32-2D-38-33-2D-38-34-2D-38-35-2D-38-36-2D-38-37-2D-38-38-2D-38-39-2D-39-30-2D-39-31-2D-39-32-2D-39-33-2D-39-34-2D-39-35-2D-39-36-2D-39-37-2D-39-38-2D-39-39-00-00", bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteEmptyStringsAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("");
|
||||
await writer.WriteValueAsync("");
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("0C-00-00-00-02-00-01-00-00-00-00-00", bson);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteCommentAsync()
|
||||
{
|
||||
await ExceptionAssert.ThrowsAsync<JsonWriterException>(async () =>
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteCommentAsync("fail");
|
||||
}, "Cannot write JSON comment as BSON. Path ''.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteConstructorAsync()
|
||||
{
|
||||
await ExceptionAssert.ThrowsAsync<JsonWriterException>(async () =>
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteStartConstructorAsync("fail");
|
||||
}, "Cannot write JSON constructor as BSON. Path ''.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteRawAsync()
|
||||
{
|
||||
await ExceptionAssert.ThrowsAsync<JsonWriterException>(async () =>
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteRawAsync("fail");
|
||||
}, "Cannot write raw JSON as BSON. Path ''.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteRawValueAsync()
|
||||
{
|
||||
await ExceptionAssert.ThrowsAsync<JsonWriterException>(async () =>
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteRawValueAsync("fail");
|
||||
}, "Cannot write raw JSON as BSON. Path ''.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteOidAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
byte[] oid = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("_oid");
|
||||
writer.WriteObjectId(oid);
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("17-00-00-00-07-5F-6F-69-64-00-01-02-03-04-05-06-07-08-09-0A-0B-0C-00", bson);
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
|
||||
CollectionAssert.AreEquivalent(oid, (byte[])reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteOidPlusContentAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("_id");
|
||||
writer.WriteObjectId(HexToBytes("4ABBED9D1D8B0F0218000001"));
|
||||
await writer.WritePropertyNameAsync("test");
|
||||
await writer.WriteValueAsync("1234£56");
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
byte[] expected = HexToBytes("29000000075F6964004ABBED9D1D8B0F02180000010274657374000900000031323334C2A335360000");
|
||||
|
||||
CollectionAssert.AreEquivalent(expected, ms.ToArray());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteRegexPlusContentAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("regex");
|
||||
writer.WriteRegex("abc", "i");
|
||||
await writer.WritePropertyNameAsync("test");
|
||||
writer.WriteRegex(string.Empty, null);
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
byte[] expected = HexToBytes("1A-00-00-00-0B-72-65-67-65-78-00-61-62-63-00-69-00-0B-74-65-73-74-00-00-00-00");
|
||||
|
||||
CollectionAssert.AreEquivalent(expected, ms.ToArray());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteReadEmptyAndNullStringsAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync("Content!");
|
||||
await writer.WriteValueAsync("");
|
||||
await writer.WriteValueAsync((string)null);
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
reader.ReadRootValueAsArray = true;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual("Content!", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual("", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Null, reader.TokenType);
|
||||
Assert.AreEqual(null, reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteDateTimesAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
writer.DateTimeKindHandling = DateTimeKind.Unspecified;
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync(new DateTime(2000, 10, 12, 20, 55, 0, DateTimeKind.Utc));
|
||||
await writer.WriteValueAsync(new DateTime(2000, 10, 12, 20, 55, 0, DateTimeKind.Local));
|
||||
await writer.WriteValueAsync(new DateTime(2000, 10, 12, 20, 55, 0, DateTimeKind.Unspecified));
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
reader.ReadRootValueAsArray = true;
|
||||
reader.DateTimeKindHandling = DateTimeKind.Utc;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Date, reader.TokenType);
|
||||
Assert.AreEqual(new DateTime(2000, 10, 12, 20, 55, 0, DateTimeKind.Utc), reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Date, reader.TokenType);
|
||||
Assert.AreEqual(new DateTime(2000, 10, 12, 20, 55, 0, DateTimeKind.Utc), reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Date, reader.TokenType);
|
||||
Assert.AreEqual(new DateTime(2000, 10, 12, 20, 55, 0, DateTimeKind.Utc), reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteValueOutsideOfObjectOrArrayAsync()
|
||||
{
|
||||
await ExceptionAssert.ThrowsAsync<JsonWriterException>(async () =>
|
||||
{
|
||||
MemoryStream stream = new MemoryStream();
|
||||
|
||||
using (BsonWriter writer = new BsonWriter(stream))
|
||||
{
|
||||
await writer.WriteValueAsync("test");
|
||||
await writer.FlushAsync();
|
||||
}
|
||||
}, "Error writing String value. BSON must start with an Object or Array. Path ''.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task DateTimeZoneHandlingAsync()
|
||||
{
|
||||
MemoryStream ms = new MemoryStream();
|
||||
JsonWriter writer = new BsonWriter(ms)
|
||||
{
|
||||
DateTimeZoneHandling = DateTimeZoneHandling.Utc
|
||||
};
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Unspecified));
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
Assert.AreEqual("10-00-00-00-09-30-00-C8-88-07-6B-DC-00-00-00-00", (BitConverter.ToString(ms.ToArray())));
|
||||
}
|
||||
|
||||
#if !PORTABLE || NETSTANDARD1_1
|
||||
[Test]
|
||||
public async Task WriteBigIntegerAsync()
|
||||
{
|
||||
BigInteger i = BigInteger.Parse("1999999999999999999999999999999999999999999999999999999999990");
|
||||
|
||||
MemoryStream ms = new MemoryStream();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("Blah");
|
||||
await writer.WriteValueAsync(i);
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
string bson = BytesToHex(ms.ToArray());
|
||||
Assert.AreEqual("2A-00-00-00-05-42-6C-61-68-00-1A-00-00-00-00-F6-FF-FF-FF-FF-FF-FF-1F-B2-21-CB-28-59-84-C4-AE-03-8A-44-34-2F-4C-4E-9E-3E-01-00", bson);
|
||||
|
||||
ms.Seek(0, SeekOrigin.Begin);
|
||||
BsonReader reader = new BsonReader(ms);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
|
||||
CollectionAssert.AreEqual(new byte[] { 246, 255, 255, 255, 255, 255, 255, 31, 178, 33, 203, 40, 89, 132, 196, 174, 3, 138, 68, 52, 47, 76, 78, 158, 62, 1 }, (byte[])reader.Value);
|
||||
Assert.AreEqual(i, new BigInteger((byte[])reader.Value));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,352 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
#if !(NET20 || NET35 || NET40 || PORTABLE40)
|
||||
|
||||
using System;
|
||||
#if DNXCORE50
|
||||
using Xunit;
|
||||
using Test = Xunit.FactAttribute;
|
||||
using Assert = Newtonsoft.Json.Tests.XUnitAssert;
|
||||
#else
|
||||
using NUnit.Framework;
|
||||
#endif
|
||||
using System.IO;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.JsonTextReaderTests
|
||||
{
|
||||
[TestFixture]
|
||||
#if !DNXCORE50
|
||||
[Category("JsonTextReaderTests")]
|
||||
#endif
|
||||
public class FloatAsyncTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public async Task Float_ReadAsString_ExactAsync()
|
||||
{
|
||||
const string testJson = "{float: 0.0620}";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(testJson));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
string s = await reader.ReadAsStringAsync();
|
||||
Assert.AreEqual("0.0620", s);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Float_NaN_ReadAsync()
|
||||
{
|
||||
const string testJson = "{float: NaN}";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(testJson));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(double.NaN, reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Float_NaN_ReadAsInt32Async()
|
||||
{
|
||||
const string testJson = "{float: NaN}";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(testJson));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsInt32Async(), "Cannot read NaN value. Path 'float', line 1, position 11.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Float_NaNAndInifinity_ReadAsDoubleAsync()
|
||||
{
|
||||
const string testJson = @"[
|
||||
NaN,
|
||||
Infinity,
|
||||
-Infinity
|
||||
]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(testJson));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
Assert.AreEqual(double.NaN, reader.ReadAsDouble());
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(double.NaN, reader.Value);
|
||||
|
||||
Assert.AreEqual(double.PositiveInfinity, reader.ReadAsDouble());
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(double.PositiveInfinity, reader.Value);
|
||||
|
||||
Assert.AreEqual(double.NegativeInfinity, reader.ReadAsDouble());
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(double.NegativeInfinity, reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Float_NaNAndInifinity_ReadAsStringAsync()
|
||||
{
|
||||
const string testJson = @"[
|
||||
NaN,
|
||||
Infinity,
|
||||
-Infinity
|
||||
]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(testJson));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
Assert.AreEqual(JsonConvert.NaN, reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual(JsonConvert.NaN, reader.Value);
|
||||
|
||||
Assert.AreEqual(JsonConvert.PositiveInfinity, reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual(JsonConvert.PositiveInfinity, reader.Value);
|
||||
|
||||
Assert.AreEqual(JsonConvert.NegativeInfinity, reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual(JsonConvert.NegativeInfinity, reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task FloatParseHandling_ReadAsStringAsync()
|
||||
{
|
||||
string json = "[9223372036854775807, 1.7976931348623157E+308, 792281625142643375935439503.35, 792281625142643375935555555555555555555555555555555555555555555555555439503.35]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
reader.FloatParseHandling = FloatParseHandling.Decimal;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.AreEqual("9223372036854775807", reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual("9223372036854775807", reader.Value);
|
||||
|
||||
Assert.AreEqual("1.7976931348623157E+308", reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual("1.7976931348623157E+308", reader.Value);
|
||||
|
||||
Assert.AreEqual("792281625142643375935439503.35", reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual("792281625142643375935439503.35", reader.Value);
|
||||
|
||||
Assert.AreEqual("792281625142643375935555555555555555555555555555555555555555555555555439503.35", reader.ReadAsString());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual("792281625142643375935555555555555555555555555555555555555555555555555439503.35", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task FloatParseHandlingAsync()
|
||||
{
|
||||
string json = "[1.0,1,9.9,1E-06]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
reader.FloatParseHandling = FloatParseHandling.Decimal;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(1.0m, reader.Value);
|
||||
Assert.AreEqual(typeof(decimal), reader.ValueType);
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(1L, reader.Value);
|
||||
Assert.AreEqual(typeof(long), reader.ValueType);
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(9.9m, reader.Value);
|
||||
Assert.AreEqual(typeof(decimal), reader.ValueType);
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(Convert.ToDecimal(1E-06), reader.Value);
|
||||
Assert.AreEqual(typeof(decimal), reader.ValueType);
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task FloatParseHandling_NaNAsync()
|
||||
{
|
||||
string json = "[NaN]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
reader.FloatParseHandling = FloatParseHandling.Decimal;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Cannot read NaN value. Path '', line 1, position 4.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task FloatingPointNonFiniteNumbersAsync()
|
||||
{
|
||||
string input = @"[
|
||||
NaN,
|
||||
Infinity,
|
||||
-Infinity
|
||||
]";
|
||||
|
||||
StringReader sr = new StringReader(input);
|
||||
|
||||
using (JsonReader jsonReader = new JsonTextReader(sr))
|
||||
{
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(jsonReader.TokenType, JsonToken.Float);
|
||||
Assert.AreEqual(jsonReader.Value, double.NaN);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(jsonReader.TokenType, JsonToken.Float);
|
||||
Assert.AreEqual(jsonReader.Value, double.PositiveInfinity);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(jsonReader.TokenType, JsonToken.Float);
|
||||
Assert.AreEqual(jsonReader.Value, double.NegativeInfinity);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ReadFloatingPointNumberAsync()
|
||||
{
|
||||
string json =
|
||||
@"[0.0,0.0,0.1,1.0,1.000001,1E-06,4.94065645841247E-324,Infinity,-Infinity,NaN,1.7976931348623157E+308,-1.7976931348623157E+308,Infinity,-Infinity,NaN,0e-10,0.25e-5,0.3e10]";
|
||||
|
||||
using (JsonReader jsonReader = new JsonTextReader(new StringReader(json)))
|
||||
{
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.StartArray, jsonReader.TokenType);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(0.0, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(0.0, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(0.1, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(1.0, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(1.000001, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(1E-06, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(4.94065645841247E-324, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.PositiveInfinity, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.NegativeInfinity, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.NaN, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.MaxValue, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.MinValue, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.PositiveInfinity, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.NegativeInfinity, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(double.NaN, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(0d, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(0.0000025d, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);
|
||||
Assert.AreEqual(3000000000d, jsonReader.Value);
|
||||
|
||||
await jsonReader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.EndArray, jsonReader.TokenType);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,990 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
#if !(NET20 || NET35 || NET40 || PORTABLE40)
|
||||
|
||||
using System;
|
||||
using System.Globalization;
|
||||
using System.Text;
|
||||
#if DNXCORE50
|
||||
using Xunit;
|
||||
using Test = Xunit.FactAttribute;
|
||||
using Assert = Newtonsoft.Json.Tests.XUnitAssert;
|
||||
#else
|
||||
using NUnit.Framework;
|
||||
#endif
|
||||
using System.IO;
|
||||
using System.Threading.Tasks;
|
||||
using Newtonsoft.Json.Tests.TestObjects.JsonTextReaderTests;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.JsonTextReaderTests
|
||||
{
|
||||
[TestFixture]
|
||||
#if !DNXCORE50
|
||||
[Category("JsonTextReaderTests")]
|
||||
#endif
|
||||
public class MiscAsyncTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public async Task LineInfoAndNewLinesAsync()
|
||||
{
|
||||
string json = "{}";
|
||||
|
||||
JsonTextReader jsonTextReader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(1, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(1, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
|
||||
Assert.AreEqual(JsonToken.EndObject, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(1, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(2, jsonTextReader.LinePosition);
|
||||
|
||||
json = "\n{\"a\":\"bc\"}";
|
||||
|
||||
jsonTextReader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(2, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(1, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(2, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(5, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(2, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(9, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(2, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(10, jsonTextReader.LinePosition);
|
||||
|
||||
json = "\n{\"a\":\n\"bc\",\"d\":true\n}";
|
||||
|
||||
jsonTextReader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(2, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(1, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(2, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(5, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(3, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(4, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(3, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(9, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Boolean, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(3, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(13, jsonTextReader.LinePosition);
|
||||
|
||||
Assert.IsTrue(await jsonTextReader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, jsonTextReader.TokenType);
|
||||
Assert.AreEqual(4, jsonTextReader.LineNumber);
|
||||
Assert.AreEqual(1, jsonTextReader.LinePosition);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task UnescapeDoubleQuotesAsync()
|
||||
{
|
||||
string json = @"{""recipe_id"":""12"",""recipe_name"":""Apocalypse Leather Armors"",""recipe_text"":""#C16------------------------------\r\n#C12Ingredients #C20\r\n#C16------------------------------\r\n\r\na piece of Leather Armor\r\n( ie #L \""Enhanced Leather Armor Boots\"" \""85644\"" )\r\n<img src=rdb:\/\/13264>\r\n\r\n#L \""Hacker Tool\"" \""87814\""\r\n<img src=rdb:\/\/99282>\r\n\r\n#L \""Clanalizer\"" \""208313\""\r\n<img src=rdb:\/\/156479>\r\n\r\n#C16------------------------------\r\n#C12Recipe #C16\r\n#C16------------------------------#C20\r\n\r\nHacker Tool\r\n#C15+#C20\r\na piece of Leather Armor\r\n#C15=#C20\r\n<img src=rdb:\/\/13264>\r\na piece of Hacked Leather Armor\r\n( ie : #L \""Hacked Leather Armor Boots\"" \""245979\"" )\r\n#C16Skills: | BE |#C20\r\n\r\n#C14------------------------------#C20\r\n\r\nClanalizer\r\n#C15+#C20\r\na piece of Hacked Leather Armor\r\n#C15=#C20\r\n<img src=rdb:\/\/13264>\r\na piece of Apocalypse Leather Armor\r\n( ie : #L \""Apocalypse Leather Armor Boots\"" \""245966\"" )\r\n#C16Skills: | ?? |#C20\r\n\r\n#C16------------------------------\r\n#C12Details#C16\r\n#C16------------------------------#C20\r\n\r\n#L \""Apocalypse Leather Armor Boots\"" \""245967\""\r\n#L \""Apocalypse Leather Armor Gloves\"" \""245969\""\r\n#L \""Apocalypse Leather Armor Helmet\"" \""245975\""\r\n#L \""Apocalypse Leather Armor Pants\"" \""245971\""\r\n#L \""Apocalypse Leather Armor Sleeves\"" \""245973\""\r\n#L \""Apocalypse Leather Body Armor\"" \""245965\""\r\n\r\n#C16------------------------------\r\n#C12Comments#C16\r\n#C16------------------------------#C20\r\n\r\nNice froob armor.. but ugleh!\r\n\r\n"",""recipe_author"":null}";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("recipe_text", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
|
||||
Assert.AreEqual("#C16------------------------------\r\n#C12Ingredients #C20\r\n#C16------------------------------\r\n\r\na piece of Leather Armor\r\n( ie #L \"Enhanced Leather Armor Boots\" \"85644\" )\r\n<img src=rdb://13264>\r\n\r\n#L \"Hacker Tool\" \"87814\"\r\n<img src=rdb://99282>\r\n\r\n#L \"Clanalizer\" \"208313\"\r\n<img src=rdb://156479>\r\n\r\n#C16------------------------------\r\n#C12Recipe #C16\r\n#C16------------------------------#C20\r\n\r\nHacker Tool\r\n#C15+#C20\r\na piece of Leather Armor\r\n#C15=#C20\r\n<img src=rdb://13264>\r\na piece of Hacked Leather Armor\r\n( ie : #L \"Hacked Leather Armor Boots\" \"245979\" )\r\n#C16Skills: | BE |#C20\r\n\r\n#C14------------------------------#C20\r\n\r\nClanalizer\r\n#C15+#C20\r\na piece of Hacked Leather Armor\r\n#C15=#C20\r\n<img src=rdb://13264>\r\na piece of Apocalypse Leather Armor\r\n( ie : #L \"Apocalypse Leather Armor Boots\" \"245966\" )\r\n#C16Skills: | ?? |#C20\r\n\r\n#C16------------------------------\r\n#C12Details#C16\r\n#C16------------------------------#C20\r\n\r\n#L \"Apocalypse Leather Armor Boots\" \"245967\"\r\n#L \"Apocalypse Leather Armor Gloves\" \"245969\"\r\n#L \"Apocalypse Leather Armor Helmet\" \"245975\"\r\n#L \"Apocalypse Leather Armor Pants\" \"245971\"\r\n#L \"Apocalypse Leather Armor Sleeves\" \"245973\"\r\n#L \"Apocalypse Leather Body Armor\" \"245965\"\r\n\r\n#C16------------------------------\r\n#C12Comments#C16\r\n#C16------------------------------#C20\r\n\r\nNice froob armor.. but ugleh!\r\n\r\n", reader.Value);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task SurrogatePairValidAsync()
|
||||
{
|
||||
string json = @"{ ""MATHEMATICAL ITALIC CAPITAL ALPHA"": ""\uD835\uDEE2"" }";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
|
||||
string s = reader.Value.ToString();
|
||||
Assert.AreEqual(2, s.Length);
|
||||
|
||||
StringInfo stringInfo = new StringInfo(s);
|
||||
Assert.AreEqual(1, stringInfo.LengthInTextElements);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task SurrogatePairReplacementAsync()
|
||||
{
|
||||
// existing good surrogate pair
|
||||
Assert.AreEqual("ABC \ud800\udc00 DEF", await ReadStringAsync("ABC \\ud800\\udc00 DEF"));
|
||||
|
||||
// invalid surrogates (two high back-to-back)
|
||||
Assert.AreEqual("ABC \ufffd\ufffd DEF", await ReadStringAsync("ABC \\ud800\\ud800 DEF"));
|
||||
|
||||
// invalid surrogates (two high back-to-back)
|
||||
Assert.AreEqual("ABC \ufffd\ufffd\u1234 DEF", await ReadStringAsync("ABC \\ud800\\ud800\\u1234 DEF"));
|
||||
|
||||
// invalid surrogates (three high back-to-back)
|
||||
Assert.AreEqual("ABC \ufffd\ufffd\ufffd DEF", await ReadStringAsync("ABC \\ud800\\ud800\\ud800 DEF"));
|
||||
|
||||
// invalid surrogates (high followed by a good surrogate pair)
|
||||
Assert.AreEqual("ABC \ufffd\ud800\udc00 DEF", await ReadStringAsync("ABC \\ud800\\ud800\\udc00 DEF"));
|
||||
|
||||
// invalid high surrogate at end of string
|
||||
Assert.AreEqual("ABC \ufffd", await ReadStringAsync("ABC \\ud800"));
|
||||
|
||||
// high surrogate not followed by low surrogate
|
||||
Assert.AreEqual("ABC \ufffd DEF", await ReadStringAsync("ABC \\ud800 DEF"));
|
||||
|
||||
// low surrogate not preceded by high surrogate
|
||||
Assert.AreEqual("ABC \ufffd\ufffd DEF", await ReadStringAsync("ABC \\udc00\\ud800 DEF"));
|
||||
|
||||
// make sure unencoded invalid surrogate characters don't make it through
|
||||
Assert.AreEqual("\ufffd\ufffd\ufffd", await ReadStringAsync("\udc00\ud800\ud800"));
|
||||
|
||||
Assert.AreEqual("ABC \ufffd\b", await ReadStringAsync("ABC \\ud800\\b"));
|
||||
Assert.AreEqual("ABC \ufffd ", await ReadStringAsync("ABC \\ud800 "));
|
||||
Assert.AreEqual("ABC \b\ufffd", await ReadStringAsync("ABC \\b\\ud800"));
|
||||
}
|
||||
|
||||
private async Task<string> ReadStringAsync(string input)
|
||||
{
|
||||
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(@"""" + input + @""""));
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StreamReader(ms));
|
||||
await reader.ReadAsync();
|
||||
|
||||
return (string)reader.Value;
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task YahooFinanceAsync()
|
||||
{
|
||||
string input = @"{
|
||||
""matches"" : [
|
||||
{""t"":""C"", ""n"":""Citigroup Inc."", ""e"":""NYSE"", ""id"":""662713""}
|
||||
,{""t"":""CHL"", ""n"":""China Mobile Ltd. (ADR)"", ""e"":""NYSE"", ""id"":""660998""}
|
||||
,{""t"":""PTR"", ""n"":""PetroChina Company Limited (ADR)"", ""e"":""NYSE"", ""id"":""664536""}
|
||||
,{""t"":""RIO"", ""n"":""Companhia Vale do Rio Doce (ADR)"", ""e"":""NYSE"", ""id"":""671472""}
|
||||
,{""t"":""RIOPR"", ""n"":""Companhia Vale do Rio Doce (ADR)"", ""e"":""NYSE"", ""id"":""3512643""}
|
||||
,{""t"":""CSCO"", ""n"":""Cisco Systems, Inc."", ""e"":""NASDAQ"", ""id"":""99624""}
|
||||
,{""t"":""CVX"", ""n"":""Chevron Corporation"", ""e"":""NYSE"", ""id"":""667226""}
|
||||
,{""t"":""TM"", ""n"":""Toyota Motor Corporation (ADR)"", ""e"":""NYSE"", ""id"":""655880""}
|
||||
,{""t"":""JPM"", ""n"":""JPMorgan Chase \\x26 Co."", ""e"":""NYSE"", ""id"":""665639""}
|
||||
,{""t"":""COP"", ""n"":""ConocoPhillips"", ""e"":""NYSE"", ""id"":""1691168""}
|
||||
,{""t"":""LFC"", ""n"":""China Life Insurance Company Ltd. (ADR)"", ""e"":""NYSE"", ""id"":""688679""}
|
||||
,{""t"":""NOK"", ""n"":""Nokia Corporation (ADR)"", ""e"":""NYSE"", ""id"":""657729""}
|
||||
,{""t"":""KO"", ""n"":""The Coca-Cola Company"", ""e"":""NYSE"", ""id"":""6550""}
|
||||
,{""t"":""VZ"", ""n"":""Verizon Communications Inc."", ""e"":""NYSE"", ""id"":""664887""}
|
||||
,{""t"":""AMX"", ""n"":""America Movil S.A.B de C.V. (ADR)"", ""e"":""NYSE"", ""id"":""665834""}],
|
||||
""all"" : false
|
||||
}
|
||||
";
|
||||
|
||||
using (JsonReader jsonReader = new JsonTextReader(new StringReader(input)))
|
||||
{
|
||||
while (await jsonReader.ReadAsync())
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task DepthAsync()
|
||||
{
|
||||
string input = @"{
|
||||
value:'Purple',
|
||||
array:[1,2,new Date(1)],
|
||||
subobject:{prop:1,proparray:[1]}
|
||||
}";
|
||||
|
||||
StringReader sr = new StringReader(input);
|
||||
|
||||
using (JsonReader reader = new JsonTextReader(sr))
|
||||
{
|
||||
Assert.AreEqual(0, reader.Depth);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.StartObject);
|
||||
Assert.AreEqual(0, reader.Depth);
|
||||
Assert.AreEqual("", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("value", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.String);
|
||||
Assert.AreEqual(reader.Value, @"Purple");
|
||||
Assert.AreEqual(reader.QuoteChar, '\'');
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("value", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("array", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.StartArray);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("array", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
|
||||
Assert.AreEqual(1L, reader.Value);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("array[0]", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
|
||||
Assert.AreEqual(2L, reader.Value);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("array[1]", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.StartConstructor);
|
||||
Assert.AreEqual("Date", reader.Value);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("array[2]", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
|
||||
Assert.AreEqual(1L, reader.Value);
|
||||
Assert.AreEqual(3, reader.Depth);
|
||||
Assert.AreEqual("array[2][0]", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.EndConstructor);
|
||||
Assert.AreEqual(null, reader.Value);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("array[2]", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.EndArray);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("array", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("subobject", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.StartObject);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("subobject", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("subobject.prop", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("subobject.prop", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("subobject.proparray", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.StartArray);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("subobject.proparray", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.Integer);
|
||||
Assert.AreEqual(3, reader.Depth);
|
||||
Assert.AreEqual("subobject.proparray[0]", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.EndArray);
|
||||
Assert.AreEqual(2, reader.Depth);
|
||||
Assert.AreEqual("subobject.proparray", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.EndObject);
|
||||
Assert.AreEqual(1, reader.Depth);
|
||||
Assert.AreEqual("subobject", reader.Path);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(reader.TokenType, JsonToken.EndObject);
|
||||
Assert.AreEqual(0, reader.Depth);
|
||||
Assert.AreEqual("", reader.Path);
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AppendCharsWhileReadingNullAsync()
|
||||
{
|
||||
string json = @"[
|
||||
{
|
||||
""$id"": ""1"",
|
||||
""Name"": ""e1"",
|
||||
""Manager"": null
|
||||
},
|
||||
{
|
||||
""$id"": ""2"",
|
||||
""Name"": ""e2"",
|
||||
""Manager"": null
|
||||
},
|
||||
{
|
||||
""$ref"": ""1""
|
||||
},
|
||||
{
|
||||
""$ref"": ""2""
|
||||
}
|
||||
]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
#if DEBUG
|
||||
reader.SetCharBuffer(new char[129]);
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < 15; i++)
|
||||
{
|
||||
await reader.ReadAsync();
|
||||
}
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Null, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task AppendCharsWhileReadingNewLineAsync()
|
||||
{
|
||||
string json = @"
|
||||
{
|
||||
""description"": ""A person"",
|
||||
""type"": ""object"",
|
||||
""properties"":
|
||||
{
|
||||
""name"": {""type"":""string""},
|
||||
""hobbies"": {
|
||||
""type"": ""array"",
|
||||
""items"": {""type"":""string""}
|
||||
}
|
||||
}
|
||||
}
|
||||
";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
#if DEBUG
|
||||
reader.SetCharBuffer(new char[129]);
|
||||
#endif
|
||||
|
||||
for (int i = 0; i < 14; i++)
|
||||
{
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("type", reader.Value);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task BufferTestAsync()
|
||||
{
|
||||
string json = @"{
|
||||
""CPU"": ""Intel"",
|
||||
""Description"": ""Amazing!\nBuy now!"",
|
||||
""Drives"": [
|
||||
""DVD read/writer"",
|
||||
""500 gigabyte hard drive"",
|
||||
""Amazing Drive" + new string('!', 9000) + @"""
|
||||
]
|
||||
}";
|
||||
|
||||
FakeArrayPool arrayPool = new FakeArrayPool();
|
||||
|
||||
for (int i = 0; i < 1000; i++)
|
||||
{
|
||||
using (JsonTextReader reader = new JsonTextReader(new StringReader(json)))
|
||||
{
|
||||
reader.ArrayPool = arrayPool;
|
||||
|
||||
while (await reader.ReadAsync())
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
if ((i + 1) % 100 == 0)
|
||||
{
|
||||
Console.WriteLine("Allocated buffers: " + arrayPool.FreeArrays.Count);
|
||||
}
|
||||
}
|
||||
|
||||
Assert.AreEqual(0, arrayPool.UsedArrays.Count);
|
||||
Assert.AreEqual(6, arrayPool.FreeArrays.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task BufferTest_WithErrorAsync()
|
||||
{
|
||||
string json = @"{
|
||||
""CPU"": ""Intel?\nYes"",
|
||||
""Description"": ""Amazin";
|
||||
|
||||
FakeArrayPool arrayPool = new FakeArrayPool();
|
||||
|
||||
try
|
||||
{
|
||||
// dispose will free used buffers
|
||||
using (JsonTextReader reader = new JsonTextReader(new StringReader(json)))
|
||||
{
|
||||
reader.ArrayPool = arrayPool;
|
||||
|
||||
while (await reader.ReadAsync())
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
Assert.Fail();
|
||||
}
|
||||
catch
|
||||
{
|
||||
}
|
||||
|
||||
Assert.AreEqual(0, arrayPool.UsedArrays.Count);
|
||||
Assert.AreEqual(2, arrayPool.FreeArrays.Count);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteReadWriteAsync()
|
||||
{
|
||||
StringBuilder sb = new StringBuilder();
|
||||
StringWriter sw = new StringWriter(sb);
|
||||
|
||||
using (JsonWriter jsonWriter = new JsonTextWriter(sw)
|
||||
{
|
||||
Formatting = Formatting.Indented
|
||||
})
|
||||
{
|
||||
await jsonWriter.WriteStartArrayAsync();
|
||||
await jsonWriter.WriteValueAsync(true);
|
||||
|
||||
await jsonWriter.WriteStartObjectAsync();
|
||||
await jsonWriter.WritePropertyNameAsync("integer");
|
||||
await jsonWriter.WriteValueAsync(99);
|
||||
await jsonWriter.WritePropertyNameAsync("string");
|
||||
await jsonWriter.WriteValueAsync("how now brown cow?");
|
||||
await jsonWriter.WritePropertyNameAsync("array");
|
||||
|
||||
await jsonWriter.WriteStartArrayAsync();
|
||||
for (int i = 0; i < 5; i++)
|
||||
{
|
||||
await jsonWriter.WriteValueAsync(i);
|
||||
}
|
||||
|
||||
await jsonWriter.WriteStartObjectAsync();
|
||||
await jsonWriter.WritePropertyNameAsync("decimal");
|
||||
await jsonWriter.WriteValueAsync(990.00990099m);
|
||||
await jsonWriter.WriteEndObjectAsync();
|
||||
|
||||
await jsonWriter.WriteValueAsync(5);
|
||||
await jsonWriter.WriteEndArrayAsync();
|
||||
|
||||
await jsonWriter.WriteEndObjectAsync();
|
||||
|
||||
await jsonWriter.WriteValueAsync("This is a string.");
|
||||
await jsonWriter.WriteNullAsync();
|
||||
await jsonWriter.WriteNullAsync();
|
||||
await jsonWriter.WriteEndArrayAsync();
|
||||
}
|
||||
|
||||
string json = sb.ToString();
|
||||
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
|
||||
object jsonObject = serializer.Deserialize(new JsonTextReader(new StringReader(json)));
|
||||
|
||||
sb = new StringBuilder();
|
||||
sw = new StringWriter(sb);
|
||||
|
||||
using (JsonWriter jsonWriter = new JsonTextWriter(sw)
|
||||
{
|
||||
Formatting = Formatting.Indented
|
||||
})
|
||||
{
|
||||
serializer.Serialize(jsonWriter, jsonObject);
|
||||
}
|
||||
|
||||
Assert.AreEqual(json, sb.ToString());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task LongStringTestAsync()
|
||||
{
|
||||
int length = 20000;
|
||||
string json = @"[""" + new string(' ', length) + @"""]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
Assert.AreEqual(typeof(string), reader.ValueType);
|
||||
Assert.AreEqual(20000, reader.Value.ToString().Length);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.None, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task EscapedUnicodeTextAsync()
|
||||
{
|
||||
string json = @"[""\u003c"",""\u5f20""]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
#if DEBUG
|
||||
reader.SetCharBuffer(new char[2]);
|
||||
#endif
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual("<", reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(24352, Convert.ToInt32(Convert.ToChar((string)reader.Value)));
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task SupportMultipleContentAsync()
|
||||
{
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(@"{'prop1':[1]} 1 2 ""name"" [][]null {}{} 1.1"));
|
||||
reader.SupportMultipleContent = true;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Null, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task SingleLineCommentsAsync()
|
||||
{
|
||||
string json = @"//comment*//*hi*/
|
||||
{//comment
|
||||
Name://comment
|
||||
true//comment after true" + StringUtils.CarriageReturn +
|
||||
@",//comment after comma" + StringUtils.CarriageReturnLineFeed +
|
||||
@"""ExpiryDate""://comment" + StringUtils.LineFeed +
|
||||
@"new " + StringUtils.LineFeed +
|
||||
@"Date
|
||||
(//comment
|
||||
null//comment
|
||||
),
|
||||
""Price"": 3.99,
|
||||
""Sizes"": //comment
|
||||
[//comment
|
||||
|
||||
""Small""//comment
|
||||
]//comment
|
||||
}//comment
|
||||
//comment 1 ";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual("comment*//*hi*/", reader.Value);
|
||||
Assert.AreEqual(1, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(2, reader.LineNumber);
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual(2, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("Name", reader.Value);
|
||||
Assert.AreEqual(3, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual(3, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
|
||||
Assert.AreEqual(true, reader.Value);
|
||||
Assert.AreEqual(4, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual("comment after true", reader.Value);
|
||||
Assert.AreEqual(4, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual("comment after comma", reader.Value);
|
||||
Assert.AreEqual(5, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("ExpiryDate", reader.Value);
|
||||
Assert.AreEqual(6, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual(6, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);
|
||||
Assert.AreEqual(9, reader.LineNumber);
|
||||
Assert.AreEqual("Date", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Null, reader.TokenType);
|
||||
Assert.AreEqual(10, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual(10, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);
|
||||
Assert.AreEqual(11, reader.LineNumber);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("Price", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("Sizes", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.String, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual("comment ", reader.Value);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual("comment 1 ", reader.Value);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task JustSinglelineCommentAsync()
|
||||
{
|
||||
string json = @"//comment";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
Assert.AreEqual("comment", reader.Value);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ScientificNotationAsync()
|
||||
{
|
||||
double d = Convert.ToDouble("6.0221418e23", CultureInfo.InvariantCulture);
|
||||
|
||||
Assert.AreEqual("6,0221418E+23", d.ToString(new CultureInfo("fr-FR")));
|
||||
Assert.AreEqual("602214180000000000000000", d.ToString("0.#############################################################################"));
|
||||
|
||||
string json = @"[0e-10,0E-10,0.25e-5,0.3e10,6.0221418e23]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
await reader.ReadAsync();
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(0d, reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(0d, reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(0.0000025d, reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(3000000000d, reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(602214180000000000000000d, reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
|
||||
reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
await reader.ReadAsync();
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(0m, reader.Value);
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(0m, reader.Value);
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(0.0000025m, reader.Value);
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(3000000000m, reader.Value);
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(602214180000000000000000m, reader.Value);
|
||||
|
||||
await reader.ReadAsync();
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task WriteReadBoundaryDecimalsAsync()
|
||||
{
|
||||
StringWriter sw = new StringWriter();
|
||||
JsonTextWriter writer = new JsonTextWriter(sw);
|
||||
|
||||
await writer.WriteStartArrayAsync();
|
||||
await writer.WriteValueAsync(decimal.MaxValue);
|
||||
await writer.WriteValueAsync(decimal.MinValue);
|
||||
await writer.WriteEndArrayAsync();
|
||||
|
||||
string json = sw.ToString();
|
||||
|
||||
StringReader sr = new StringReader(json);
|
||||
JsonTextReader reader = new JsonTextReader(sr);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
decimal? max = await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(decimal.MaxValue, max);
|
||||
|
||||
decimal? min = await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(decimal.MinValue, min);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
#if !DNXCORE50
|
||||
[Test]
|
||||
public async Task LinePositionOnNewLineAsync()
|
||||
{
|
||||
string json1 = "{'a':'bc'}";
|
||||
|
||||
JsonTextReader r = new JsonTextReader(new StringReader(json1));
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(1, r.LineNumber);
|
||||
Assert.AreEqual(1, r.LinePosition);
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(1, r.LineNumber);
|
||||
Assert.AreEqual(5, r.LinePosition);
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(1, r.LineNumber);
|
||||
Assert.AreEqual(9, r.LinePosition);
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(1, r.LineNumber);
|
||||
Assert.AreEqual(10, r.LinePosition);
|
||||
|
||||
Assert.IsFalse(await r.ReadAsync());
|
||||
|
||||
string json2 = "\n{'a':'bc'}";
|
||||
|
||||
r = new JsonTextReader(new StringReader(json2));
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(2, r.LineNumber);
|
||||
Assert.AreEqual(1, r.LinePosition);
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(2, r.LineNumber);
|
||||
Assert.AreEqual(5, r.LinePosition);
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(2, r.LineNumber);
|
||||
Assert.AreEqual(9, r.LinePosition);
|
||||
|
||||
Assert.IsTrue(await r.ReadAsync());
|
||||
Assert.AreEqual(2, r.LineNumber);
|
||||
Assert.AreEqual(10, r.LinePosition);
|
||||
|
||||
Assert.IsFalse(await r.ReadAsync());
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,492 @@
|
||||
#region License
|
||||
// Copyright (c) 2007 James Newton-King
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person
|
||||
// obtaining a copy of this software and associated documentation
|
||||
// files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use,
|
||||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
// copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following
|
||||
// conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be
|
||||
// included in all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
// OTHER DEALINGS IN THE SOFTWARE.
|
||||
#endregion
|
||||
|
||||
#if !(NET20 || NET35 || NET40 || PORTABLE40)
|
||||
|
||||
using System;
|
||||
using System.Text;
|
||||
#if DNXCORE50
|
||||
using Xunit;
|
||||
using Test = Xunit.FactAttribute;
|
||||
using Assert = Newtonsoft.Json.Tests.XUnitAssert;
|
||||
#else
|
||||
using NUnit.Framework;
|
||||
#endif
|
||||
using System.IO;
|
||||
using System.Threading.Tasks;
|
||||
using Newtonsoft.Json.Tests.TestObjects.JsonTextReaderTests;
|
||||
using Newtonsoft.Json.Utilities;
|
||||
|
||||
namespace Newtonsoft.Json.Tests.JsonTextReaderTests
|
||||
{
|
||||
[TestFixture]
|
||||
#if !DNXCORE50
|
||||
[Category("JsonTextReaderTests")]
|
||||
#endif
|
||||
public class ParseAsyncTests : TestFixtureBase
|
||||
{
|
||||
[Test]
|
||||
public async Task ParseAdditionalContent_WhitespaceAsync()
|
||||
{
|
||||
string json = @"[
|
||||
""Small"",
|
||||
""Medium"",
|
||||
""Large""
|
||||
]
|
||||
|
||||
";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
while (await reader.ReadAsync())
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParsingQuotedPropertyWithControlCharactersAsync()
|
||||
{
|
||||
JsonReader reader = new JsonTextReader(new StringReader(@"{'hi\r\nbye':1}"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
Assert.AreEqual("hi\r\nbye", reader.Value);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
Assert.AreEqual(1L, reader.Value);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseIntegersAsync()
|
||||
{
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader("1"));
|
||||
Assert.AreEqual(1, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-1"));
|
||||
Assert.AreEqual(-1, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("0"));
|
||||
Assert.AreEqual(0, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-0"));
|
||||
Assert.AreEqual(0, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(int.MaxValue.ToString()));
|
||||
Assert.AreEqual(int.MaxValue, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(int.MinValue.ToString()));
|
||||
Assert.AreEqual(int.MinValue, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(long.MaxValue.ToString()));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsInt32Async(), "JSON integer 9223372036854775807 is too large or small for an Int32. Path '', line 1, position 19.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("9999999999999999999999999999999999999999999999999999999999999999999999999999asdasdasd"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsInt32Async(), "Unexpected character encountered while parsing number: s. Path '', line 1, position 77.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1E-06"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsInt32Async(), "Input string '1E-06' is not a valid integer. Path '', line 1, position 5.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1.1"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsInt32Async(), "Input string '1.1' is not a valid integer. Path '', line 1, position 3.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader(""));
|
||||
Assert.AreEqual(null, await reader.ReadAsInt32Async());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsInt32Async(), "Input string '-' is not a valid integer. Path '', line 1, position 1.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseDecimalsAsync()
|
||||
{
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader("1.1"));
|
||||
Assert.AreEqual(1.1m, await reader.ReadAsDecimalAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-1.1"));
|
||||
Assert.AreEqual(-1.1m, await reader.ReadAsDecimalAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("0.0"));
|
||||
Assert.AreEqual(0.0m, await reader.ReadAsDecimalAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-0.0"));
|
||||
Assert.AreEqual(0, await reader.ReadAsDecimalAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("9999999999999999999999999999999999999999999999999999999999999999999999999999asdasdasd"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsDecimalAsync(), "Unexpected character encountered while parsing number: s. Path '', line 1, position 77.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("9999999999999999999999999999999999999999999999999999999999999999999999999999asdasdasd"));
|
||||
reader.FloatParseHandling = FloatParseHandling.Decimal;
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Unexpected character encountered while parsing number: s. Path '', line 1, position 77.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1E-06"));
|
||||
Assert.AreEqual(0.000001m, await reader.ReadAsDecimalAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(""));
|
||||
Assert.AreEqual(null, await reader.ReadAsDecimalAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsDecimalAsync(), "Input string '-' is not a valid decimal. Path '', line 1, position 1.");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseDoublesAsync()
|
||||
{
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader("1.1"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(1.1d, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-1.1"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(-1.1d, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader("0.0"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(0.0d, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-0.0"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(-0.0d, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader("9999999999999999999999999999999999999999999999999999999999999999999999999999asdasdasd"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Unexpected character encountered while parsing number: s. Path '', line 1, position 77.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1E-06"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(0.000001d, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader(""));
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Input string '-' is not a valid number. Path '', line 1, position 1.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1.7976931348623157E+308"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(Double.MaxValue, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-1.7976931348623157E+308"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(Double.MinValue, reader.Value);
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1E+309"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Input string '1E+309' is not a valid number. Path '', line 1, position 6.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("-1E+5000"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Input string '-1E+5000' is not a valid number. Path '', line 1, position 8.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("5.1231231E"));
|
||||
await ExceptionAssert.ThrowsAsync<JsonReaderException>(async () => await reader.ReadAsync(), "Input string '5.1231231E' is not a valid number. Path '', line 1, position 10.");
|
||||
|
||||
reader = new JsonTextReader(new StringReader("1E-23"));
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(typeof(double), reader.ValueType);
|
||||
Assert.AreEqual(1e-23, reader.Value);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseArrayWithMissingValuesAsync()
|
||||
{
|
||||
string json = "[,,, \n\r\n \0 \r , , ]";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Undefined, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Undefined, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Undefined, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Undefined, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Undefined, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseBooleanWithNoExtraContentAsync()
|
||||
{
|
||||
string json = "[true ";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseContentDelimitedByNonStandardWhitespaceAsync()
|
||||
{
|
||||
string json = "\x00a0{\x00a0'h\x00a0i\x00a0'\x00a0:\x00a0[\x00a0true\x00a0,\x00a0new\x00a0Date\x00a0(\x00a0)\x00a0]\x00a0/*\x00a0comment\x00a0*/\x00a0}\x00a0";
|
||||
JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.Comment, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseObjectWithNoEndAsync()
|
||||
{
|
||||
string json = "{hi:1, ";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsFalse(await reader.ReadAsync());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseEmptyArrayAsync()
|
||||
{
|
||||
string json = "[]";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseEmptyObjectAsync()
|
||||
{
|
||||
string json = "{}";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartObject, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseEmptyConstructorAsync()
|
||||
{
|
||||
string json = "new Date()";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseHexNumberAsync()
|
||||
{
|
||||
string json = @"0x20";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(32m, reader.Value);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseNumbersAsync()
|
||||
{
|
||||
string json = @"[0,1,2 , 3]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
|
||||
|
||||
await reader.ReadAsync();
|
||||
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseLineFeedDelimitedConstructorAsync()
|
||||
{
|
||||
string json = "new Date\n()";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual("Date", reader.Value);
|
||||
Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseNullStringConstructorAsync()
|
||||
{
|
||||
string json = "new Date\0()";
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
#if DEBUG
|
||||
reader.SetCharBuffer(new char[7]);
|
||||
#endif
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual("Date", reader.Value);
|
||||
Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task ParseOctalNumberAsync()
|
||||
{
|
||||
string json = @"010";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
|
||||
await reader.ReadAsDecimalAsync();
|
||||
Assert.AreEqual(JsonToken.Float, reader.TokenType);
|
||||
Assert.AreEqual(8m, reader.Value);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task DateParseHandlingAsync()
|
||||
{
|
||||
string json = @"[""1970-01-01T00:00:00Z"",""\/Date(0)\/""]";
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
reader.DateParseHandling = DateParseHandling.DateTime;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(new DateTime(DateTimeUtils.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTime), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(new DateTime(DateTimeUtils.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTime), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(json));
|
||||
reader.DateParseHandling = DateParseHandling.DateTimeOffset;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(new DateTimeOffset(DateTimeUtils.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(new DateTimeOffset(DateTimeUtils.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(json));
|
||||
reader.DateParseHandling = DateParseHandling.None;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(@"1970-01-01T00:00:00Z", reader.Value);
|
||||
Assert.AreEqual(typeof(string), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
Assert.AreEqual(@"/Date(0)/", reader.Value);
|
||||
Assert.AreEqual(typeof(string), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(json));
|
||||
reader.DateParseHandling = DateParseHandling.DateTime;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
await reader.ReadAsDateTimeOffsetAsync();
|
||||
Assert.AreEqual(new DateTimeOffset(DateTimeUtils.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);
|
||||
await reader.ReadAsDateTimeOffsetAsync();
|
||||
Assert.AreEqual(new DateTimeOffset(DateTimeUtils.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
|
||||
reader = new JsonTextReader(new StringReader(json));
|
||||
reader.DateParseHandling = DateParseHandling.DateTimeOffset;
|
||||
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
await reader.ReadAsDateTimeAsync();
|
||||
Assert.AreEqual(new DateTime(DateTimeUtils.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTime), reader.ValueType);
|
||||
await reader.ReadAsDateTimeAsync();
|
||||
Assert.AreEqual(new DateTime(DateTimeUtils.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);
|
||||
Assert.AreEqual(typeof(DateTime), reader.ValueType);
|
||||
Assert.IsTrue(await reader.ReadAsync());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1649,7 +1649,7 @@ null//comment
|
||||
|
||||
public class CustomJsonTextWriter : JsonTextWriter
|
||||
{
|
||||
private readonly TextWriter _writer;
|
||||
protected readonly TextWriter _writer;
|
||||
|
||||
public CustomJsonTextWriter(TextWriter textWriter) : base(textWriter)
|
||||
{
|
||||
|
||||
@@ -107,8 +107,10 @@
|
||||
</Reference>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="Bson\BsonWriterTests.cs" />
|
||||
<Compile Include="Bson\BsonReaderAsyncTests.cs" />
|
||||
<Compile Include="Bson\BsonReaderTests.cs" />
|
||||
<Compile Include="Bson\BsonWriterAsyncTests.cs" />
|
||||
<Compile Include="Bson\BsonWriterTests.cs" />
|
||||
<Compile Include="Converters\BinaryConverterTests.cs" />
|
||||
<Compile Include="Converters\DiscriminatedUnionConverterTests.cs" />
|
||||
<Compile Include="Converters\ExpandoObjectConverterTests.cs" />
|
||||
@@ -122,10 +124,15 @@
|
||||
<Compile Include="Converters\VersionConverterTests.cs" />
|
||||
<Compile Include="JsonArrayAttributeTests.cs" />
|
||||
<Compile Include="ExceptionTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ExceptionHandlingAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ExceptionHandlingTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\FloatAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\FloatTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\MiscAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\MiscTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ParseAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ParseTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ReadAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ReadTests.cs" />
|
||||
<Compile Include="JsonValidatingReaderTests.cs" />
|
||||
<Compile Include="Linq\ComponentModel\BindingTests.cs" />
|
||||
@@ -341,6 +348,7 @@
|
||||
<Compile Include="JsonConvertTest.cs" />
|
||||
<Compile Include="Converters\JavaScriptDateTimeConverterTests.cs" />
|
||||
<Compile Include="Serialization\JsonSerializerTest.cs" />
|
||||
<Compile Include="JsonTextWriterAsyncTests.cs" />
|
||||
<Compile Include="JsonTextWriterTest.cs" />
|
||||
<Compile Include="Linq\JTokenReaderTest.cs" />
|
||||
<Compile Include="Linq\JTokenWriterTest.cs" />
|
||||
@@ -430,4 +438,4 @@
|
||||
<Target Name="AfterBuild">
|
||||
</Target>
|
||||
-->
|
||||
</Project>
|
||||
</Project>
|
||||
|
||||
@@ -49,7 +49,9 @@
|
||||
<Reference Include="System.Xml" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<Compile Include="Bson\BsonReaderAsyncTests.cs" />
|
||||
<Compile Include="Bson\BsonReaderTests.cs" />
|
||||
<Compile Include="Bson\BsonWriterAsyncTests.cs" />
|
||||
<Compile Include="Bson\BsonWriterTests.cs" />
|
||||
<Compile Include="Converters\BinaryConverterTests.cs" />
|
||||
<Compile Include="Converters\CustomCreationConverterTests.cs" />
|
||||
@@ -222,8 +224,14 @@
|
||||
<Compile Include="ExceptionTests.cs" />
|
||||
<Compile Include="JsonArrayAttributeTests.cs" />
|
||||
<Compile Include="JsonConvertTest.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ExceptionHandlingAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\FloatAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\MiscAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\MiscTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ExceptionHandlingTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ParseAsyncTests.cs" />
|
||||
<Compile Include="JsonTextReaderTests\ReadAsyncTests.cs" />
|
||||
<Compile Include="JsonTextWriterAsyncTests.cs" />
|
||||
<Compile Include="TestObjects\JsonReaderStubWithIsClosed.cs" />
|
||||
<Compile Include="TestObjects\JsonTextReaderTests\FakeArrayPool.cs" />
|
||||
<Compile Include="JsonTextReaderTests\FloatTests.cs" />
|
||||
|
||||
@@ -43,6 +43,7 @@ using Newtonsoft.Json.Bson;
|
||||
using System.Runtime.Serialization.Formatters.Binary;
|
||||
using Newtonsoft.Json.Linq;
|
||||
using Newtonsoft.Json.Converters;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace Newtonsoft.Json.Tests
|
||||
{
|
||||
@@ -69,8 +70,8 @@ namespace Newtonsoft.Json.Tests
|
||||
#if DEBUG
|
||||
public int Iterations = 1;
|
||||
#else
|
||||
public int Iterations = 100;
|
||||
//public int Iterations = 10000;
|
||||
//public int Iterations = 100;
|
||||
public int Iterations = 10000;
|
||||
#endif
|
||||
|
||||
#region Data
|
||||
@@ -99,6 +100,7 @@ namespace Newtonsoft.Json.Tests
|
||||
JsonNetBinary,
|
||||
JsonNetLinq,
|
||||
JsonNetManual,
|
||||
JsonNetManualAsync,
|
||||
BinaryFormatter,
|
||||
JavaScriptSerializer,
|
||||
DataContractSerializer,
|
||||
@@ -136,6 +138,14 @@ namespace Newtonsoft.Json.Tests
|
||||
SerializeTests(test);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task SerializeAsync()
|
||||
{
|
||||
TestClass test = CreateSerializationObject();
|
||||
|
||||
await BenchmarkSerializeMethodAsync(SerializeMethod.JsonNetManualAsync, test);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ReadLargeJson()
|
||||
{
|
||||
@@ -238,6 +248,12 @@ namespace Newtonsoft.Json.Tests
|
||||
BenchmarkDeserializeMethod<TestClass>(SerializeMethod.JsonNetBinary, HexToBytes(BsonHex));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task DeserializeAsync()
|
||||
{
|
||||
await BenchmarkDeserializeMethodAsync<TestClass>(SerializeMethod.JsonNetManualAsync, JsonText);
|
||||
}
|
||||
|
||||
public void DeserializeTests<T>(string json)
|
||||
{
|
||||
BenchmarkDeserializeMethod<T>(SerializeMethod.JavaScriptSerializer, json);
|
||||
@@ -641,6 +657,27 @@ If attributes are not mentioned, default values are used in each case.
|
||||
#region Serialize
|
||||
private static readonly byte[] Buffer = new byte[4096];
|
||||
|
||||
public async Task BenchmarkSerializeMethodAsync(SerializeMethod method, object value)
|
||||
{
|
||||
await SerializeAsync(method, value);
|
||||
|
||||
Stopwatch timed = new Stopwatch();
|
||||
timed.Start();
|
||||
|
||||
string json = null;
|
||||
for (int x = 0; x < Iterations; x++)
|
||||
{
|
||||
json = await SerializeAsync(method, value);
|
||||
}
|
||||
|
||||
timed.Stop();
|
||||
|
||||
Console.WriteLine("Serialize method: {0}", method);
|
||||
Console.WriteLine("{0} ms", timed.ElapsedMilliseconds);
|
||||
Console.WriteLine(json);
|
||||
Console.WriteLine();
|
||||
}
|
||||
|
||||
public void BenchmarkSerializeMethod(SerializeMethod method, object value)
|
||||
{
|
||||
Serialize(method, value);
|
||||
@@ -738,6 +775,83 @@ If attributes are not mentioned, default values are used in each case.
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<string> SerializeAsync(SerializeMethod method, object value)
|
||||
{
|
||||
string json;
|
||||
|
||||
switch (method)
|
||||
{
|
||||
case SerializeMethod.JsonNetManualAsync:
|
||||
{
|
||||
TestClass c = value as TestClass;
|
||||
if (c != null)
|
||||
{
|
||||
StringWriter sw = new StringWriter();
|
||||
JsonTextWriter writer = new JsonTextWriter(sw);
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("strings");
|
||||
await writer.WriteStartArrayAsync();
|
||||
foreach (string s in c.strings)
|
||||
{
|
||||
await writer.WriteValueAsync(s);
|
||||
}
|
||||
await writer.WriteEndArrayAsync();
|
||||
await writer.WritePropertyNameAsync("dictionary");
|
||||
await writer.WriteStartObjectAsync();
|
||||
foreach (KeyValuePair<string, int> keyValuePair in c.dictionary)
|
||||
{
|
||||
await writer.WritePropertyNameAsync(keyValuePair.Key);
|
||||
await writer.WriteValueAsync(keyValuePair.Value);
|
||||
}
|
||||
await writer.WriteEndObjectAsync();
|
||||
await writer.WritePropertyNameAsync("Name");
|
||||
await writer.WriteValueAsync(c.Name);
|
||||
await writer.WritePropertyNameAsync("Now");
|
||||
await writer.WriteValueAsync(c.Now);
|
||||
await writer.WritePropertyNameAsync("BigNumber");
|
||||
await writer.WriteValueAsync(c.BigNumber);
|
||||
await writer.WritePropertyNameAsync("Address1");
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("Street");
|
||||
await writer.WriteValueAsync(c.BigNumber);
|
||||
await writer.WritePropertyNameAsync("Street");
|
||||
await writer.WriteValueAsync(c.BigNumber);
|
||||
await writer.WritePropertyNameAsync("Street");
|
||||
await writer.WriteValueAsync(c.BigNumber);
|
||||
await writer.WriteEndObjectAsync();
|
||||
await writer.WritePropertyNameAsync("Addresses");
|
||||
await writer.WriteStartArrayAsync();
|
||||
foreach (Address address in c.Addresses)
|
||||
{
|
||||
await writer.WriteStartObjectAsync();
|
||||
await writer.WritePropertyNameAsync("Street");
|
||||
await writer.WriteValueAsync(address.Street);
|
||||
await writer.WritePropertyNameAsync("Phone");
|
||||
await writer.WriteValueAsync(address.Phone);
|
||||
await writer.WritePropertyNameAsync("Entered");
|
||||
await writer.WriteValueAsync(address.Entered);
|
||||
await writer.WriteEndObjectAsync();
|
||||
}
|
||||
await writer.WriteEndArrayAsync();
|
||||
await writer.WriteEndObjectAsync();
|
||||
|
||||
await writer.FlushAsync();
|
||||
json = sw.ToString();
|
||||
}
|
||||
else
|
||||
{
|
||||
json = string.Empty;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
json = string.Empty;
|
||||
break;
|
||||
}
|
||||
|
||||
return json;
|
||||
}
|
||||
|
||||
private string Serialize(SerializeMethod method, object value)
|
||||
{
|
||||
string json;
|
||||
@@ -751,111 +865,111 @@ If attributes are not mentioned, default values are used in each case.
|
||||
json = JsonConvert.SerializeObject(value, new IsoDateTimeConverter());
|
||||
break;
|
||||
case SerializeMethod.JsonNetLinq:
|
||||
{
|
||||
TestClass c = value as TestClass;
|
||||
if (c != null)
|
||||
{
|
||||
JObject o = new JObject(
|
||||
new JProperty("strings", new JArray(
|
||||
c.strings
|
||||
)),
|
||||
new JProperty("dictionary", new JObject(c.dictionary.Select(d => new JProperty(d.Key, d.Value)))),
|
||||
new JProperty("Name", c.Name),
|
||||
new JProperty("Now", c.Now),
|
||||
new JProperty("BigNumber", c.BigNumber),
|
||||
new JProperty("Address1", new JObject(
|
||||
new JProperty("Street", c.Address1.Street),
|
||||
new JProperty("Phone", c.Address1.Phone),
|
||||
new JProperty("Entered", c.Address1.Entered))),
|
||||
new JProperty("Addresses", new JArray(c.Addresses.Select(a =>
|
||||
new JObject(
|
||||
new JProperty("Street", a.Street),
|
||||
new JProperty("Phone", a.Phone),
|
||||
new JProperty("Entered", a.Entered)))))
|
||||
);
|
||||
TestClass c = value as TestClass;
|
||||
if (c != null)
|
||||
{
|
||||
JObject o = new JObject(
|
||||
new JProperty("strings", new JArray(
|
||||
c.strings
|
||||
)),
|
||||
new JProperty("dictionary", new JObject(c.dictionary.Select(d => new JProperty(d.Key, d.Value)))),
|
||||
new JProperty("Name", c.Name),
|
||||
new JProperty("Now", c.Now),
|
||||
new JProperty("BigNumber", c.BigNumber),
|
||||
new JProperty("Address1", new JObject(
|
||||
new JProperty("Street", c.Address1.Street),
|
||||
new JProperty("Phone", c.Address1.Phone),
|
||||
new JProperty("Entered", c.Address1.Entered))),
|
||||
new JProperty("Addresses", new JArray(c.Addresses.Select(a =>
|
||||
new JObject(
|
||||
new JProperty("Street", a.Street),
|
||||
new JProperty("Phone", a.Phone),
|
||||
new JProperty("Entered", a.Entered)))))
|
||||
);
|
||||
|
||||
json = o.ToString(Formatting.None);
|
||||
json = o.ToString(Formatting.None);
|
||||
}
|
||||
else
|
||||
{
|
||||
json = string.Empty;
|
||||
}
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
json = string.Empty;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SerializeMethod.JsonNetManual:
|
||||
{
|
||||
TestClass c = value as TestClass;
|
||||
if (c != null)
|
||||
{
|
||||
StringWriter sw = new StringWriter();
|
||||
JsonTextWriter writer = new JsonTextWriter(sw);
|
||||
writer.WriteStartObject();
|
||||
writer.WritePropertyName("strings");
|
||||
writer.WriteStartArray();
|
||||
foreach (string s in c.strings)
|
||||
{
|
||||
writer.WriteValue(s);
|
||||
}
|
||||
writer.WriteEndArray();
|
||||
writer.WritePropertyName("dictionary");
|
||||
writer.WriteStartObject();
|
||||
foreach (KeyValuePair<string, int> keyValuePair in c.dictionary)
|
||||
{
|
||||
writer.WritePropertyName(keyValuePair.Key);
|
||||
writer.WriteValue(keyValuePair.Value);
|
||||
}
|
||||
writer.WriteEndObject();
|
||||
writer.WritePropertyName("Name");
|
||||
writer.WriteValue(c.Name);
|
||||
writer.WritePropertyName("Now");
|
||||
writer.WriteValue(c.Now);
|
||||
writer.WritePropertyName("BigNumber");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WritePropertyName("Address1");
|
||||
writer.WriteStartObject();
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WriteEndObject();
|
||||
writer.WritePropertyName("Addresses");
|
||||
writer.WriteStartArray();
|
||||
foreach (Address address in c.Addresses)
|
||||
TestClass c = value as TestClass;
|
||||
if (c != null)
|
||||
{
|
||||
StringWriter sw = new StringWriter();
|
||||
JsonTextWriter writer = new JsonTextWriter(sw);
|
||||
writer.WriteStartObject();
|
||||
writer.WritePropertyName("strings");
|
||||
writer.WriteStartArray();
|
||||
foreach (string s in c.strings)
|
||||
{
|
||||
writer.WriteValue(s);
|
||||
}
|
||||
writer.WriteEndArray();
|
||||
writer.WritePropertyName("dictionary");
|
||||
writer.WriteStartObject();
|
||||
foreach (KeyValuePair<string, int> keyValuePair in c.dictionary)
|
||||
{
|
||||
writer.WritePropertyName(keyValuePair.Key);
|
||||
writer.WriteValue(keyValuePair.Value);
|
||||
}
|
||||
writer.WriteEndObject();
|
||||
writer.WritePropertyName("Name");
|
||||
writer.WriteValue(c.Name);
|
||||
writer.WritePropertyName("Now");
|
||||
writer.WriteValue(c.Now);
|
||||
writer.WritePropertyName("BigNumber");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WritePropertyName("Address1");
|
||||
writer.WriteStartObject();
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(address.Street);
|
||||
writer.WritePropertyName("Phone");
|
||||
writer.WriteValue(address.Phone);
|
||||
writer.WritePropertyName("Entered");
|
||||
writer.WriteValue(address.Entered);
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(c.BigNumber);
|
||||
writer.WriteEndObject();
|
||||
writer.WritePropertyName("Addresses");
|
||||
writer.WriteStartArray();
|
||||
foreach (Address address in c.Addresses)
|
||||
{
|
||||
writer.WriteStartObject();
|
||||
writer.WritePropertyName("Street");
|
||||
writer.WriteValue(address.Street);
|
||||
writer.WritePropertyName("Phone");
|
||||
writer.WriteValue(address.Phone);
|
||||
writer.WritePropertyName("Entered");
|
||||
writer.WriteValue(address.Entered);
|
||||
writer.WriteEndObject();
|
||||
}
|
||||
writer.WriteEndArray();
|
||||
writer.WriteEndObject();
|
||||
|
||||
writer.Flush();
|
||||
json = sw.ToString();
|
||||
}
|
||||
writer.WriteEndArray();
|
||||
writer.WriteEndObject();
|
||||
|
||||
writer.Flush();
|
||||
json = sw.ToString();
|
||||
else
|
||||
{
|
||||
json = string.Empty;
|
||||
}
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
json = string.Empty;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case SerializeMethod.JsonNetBinary:
|
||||
{
|
||||
MemoryStream ms = new MemoryStream(Buffer);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
serializer.Serialize(writer, value);
|
||||
{
|
||||
MemoryStream ms = new MemoryStream(Buffer);
|
||||
JsonSerializer serializer = new JsonSerializer();
|
||||
BsonWriter writer = new BsonWriter(ms);
|
||||
serializer.Serialize(writer, value);
|
||||
|
||||
//json = BitConverter.ToString(ms.ToArray(), 0, (int)ms.Position);
|
||||
json = "Bytes = " + ms.Position;
|
||||
break;
|
||||
}
|
||||
//json = BitConverter.ToString(ms.ToArray(), 0, (int)ms.Position);
|
||||
json = "Bytes = " + ms.Position;
|
||||
break;
|
||||
}
|
||||
case SerializeMethod.JavaScriptSerializer:
|
||||
json = SerializeWebExtensions(value);
|
||||
break;
|
||||
@@ -918,6 +1032,35 @@ If attributes are not mentioned, default values are used in each case.
|
||||
Console.WriteLine();
|
||||
}
|
||||
|
||||
public async Task BenchmarkDeserializeMethodAsync<T>(SerializeMethod method, object json, int? iterations = null, bool warmUp = true)
|
||||
{
|
||||
GC.Collect();
|
||||
GC.WaitForPendingFinalizers();
|
||||
|
||||
if (warmUp)
|
||||
{
|
||||
await DeserializeAsync<T>(method, json);
|
||||
}
|
||||
|
||||
Stopwatch timed = new Stopwatch();
|
||||
timed.Start();
|
||||
|
||||
iterations = iterations ?? Iterations;
|
||||
|
||||
T value = default(T);
|
||||
for (int x = 0; x < iterations.Value; x++)
|
||||
{
|
||||
value = await DeserializeAsync<T>(method, json);
|
||||
}
|
||||
|
||||
timed.Stop();
|
||||
|
||||
Console.WriteLine("Deserialize method: {0}", method);
|
||||
Console.WriteLine("{0} ms", timed.ElapsedMilliseconds);
|
||||
Console.WriteLine(value);
|
||||
Console.WriteLine();
|
||||
}
|
||||
|
||||
public T DeserializeJsonNet<T>(string json, bool isoDateTimeConverter)
|
||||
{
|
||||
Type type = typeof(T);
|
||||
@@ -940,6 +1083,66 @@ If attributes are not mentioned, default values are used in each case.
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<TestClass> DeserializeJsonNetManualAsync(string json)
|
||||
{
|
||||
TestClass c = new TestClass();
|
||||
|
||||
JsonTextReader reader = new JsonTextReader(new StringReader(json));
|
||||
await reader.ReadAsync();
|
||||
while (await reader.ReadAsync())
|
||||
{
|
||||
if (reader.TokenType == JsonToken.PropertyName)
|
||||
{
|
||||
string propertyName = (string)reader.Value;
|
||||
switch (propertyName)
|
||||
{
|
||||
case "strings":
|
||||
await reader.ReadAsync();
|
||||
while (await reader.ReadAsync() && reader.TokenType != JsonToken.EndArray)
|
||||
{
|
||||
c.strings.Add((string)reader.Value);
|
||||
}
|
||||
break;
|
||||
case "dictionary":
|
||||
await reader.ReadAsync();
|
||||
while (await reader.ReadAsync() && reader.TokenType != JsonToken.EndObject)
|
||||
{
|
||||
string key = (string)reader.Value;
|
||||
c.dictionary.Add(key, reader.ReadAsInt32().GetValueOrDefault());
|
||||
}
|
||||
break;
|
||||
case "Name":
|
||||
c.Name = reader.ReadAsString();
|
||||
break;
|
||||
case "Now":
|
||||
c.Now = reader.ReadAsDateTime().GetValueOrDefault();
|
||||
break;
|
||||
case "BigNumber":
|
||||
c.BigNumber = reader.ReadAsDecimal().GetValueOrDefault();
|
||||
break;
|
||||
case "Address1":
|
||||
await reader.ReadAsync();
|
||||
c.Address1 = CreateAddress(reader);
|
||||
break;
|
||||
case "Addresses":
|
||||
await reader.ReadAsync();
|
||||
while (await reader.ReadAsync() && reader.TokenType != JsonToken.EndArray)
|
||||
{
|
||||
var address = CreateAddress(reader);
|
||||
c.Addresses.Add(address);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
public TestClass DeserializeJsonNetManual(string json)
|
||||
{
|
||||
TestClass c = new TestClass();
|
||||
@@ -1056,6 +1259,22 @@ If attributes are not mentioned, default values are used in each case.
|
||||
return (T)dataContractSerializer.ReadObject(ms);
|
||||
}
|
||||
|
||||
private async Task<T> DeserializeAsync<T>(SerializeMethod method, object json)
|
||||
{
|
||||
switch (method)
|
||||
{
|
||||
case SerializeMethod.JsonNetManualAsync:
|
||||
if (typeof(T) == typeof(TestClass))
|
||||
{
|
||||
return (T)(object)await DeserializeJsonNetManualAsync((string)json);
|
||||
}
|
||||
|
||||
return default(T);
|
||||
default:
|
||||
throw new ArgumentOutOfRangeException(nameof(method));
|
||||
}
|
||||
}
|
||||
|
||||
private T Deserialize<T>(SerializeMethod method, object json)
|
||||
{
|
||||
switch (method)
|
||||
|
||||
@@ -45,6 +45,9 @@ using NUnit.Framework;
|
||||
#endif
|
||||
using Newtonsoft.Json.Utilities;
|
||||
using System.Collections;
|
||||
#if !(NET20 || NET35 || NET40 || PORTABLE40)
|
||||
using System.Threading.Tasks;
|
||||
#endif
|
||||
#if NET20
|
||||
using Newtonsoft.Json.Utilities.LinqBridge;
|
||||
#else
|
||||
@@ -379,5 +382,40 @@ namespace Newtonsoft.Json.Tests
|
||||
throw new Exception(string.Format("Exception of type {0} expected; got exception of type {1}.", typeof(TException).Name, ex.GetType().Name), ex);
|
||||
}
|
||||
}
|
||||
|
||||
#if !(NET20 || NET35 || NET40 || PORTABLE40)
|
||||
public static async Task<TException> ThrowsAsync<TException>(Func<Task> action, params string[] possibleMessages)
|
||||
where TException : Exception
|
||||
{
|
||||
try
|
||||
{
|
||||
await action();
|
||||
|
||||
Assert.Fail("Exception of type {0} expected. No exception thrown.", typeof(TException).Name);
|
||||
return null;
|
||||
}
|
||||
catch (TException ex)
|
||||
{
|
||||
if (possibleMessages == null || possibleMessages.Length == 0)
|
||||
{
|
||||
return ex;
|
||||
}
|
||||
foreach (string possibleMessage in possibleMessages)
|
||||
{
|
||||
if (StringAssert.Equals(possibleMessage, ex.Message))
|
||||
{
|
||||
return ex;
|
||||
}
|
||||
}
|
||||
|
||||
throw new Exception("Unexpected exception message." + Environment.NewLine + "Expected one of: " + string.Join(Environment.NewLine, possibleMessages) + Environment.NewLine + "Got: " + ex.Message + Environment.NewLine + Environment.NewLine + ex);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception(string.Format("Exception of type {0} expected; got exception of type {1}.", typeof(TException).Name, ex.GetType().Name), ex);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user