-Rewrote JsonTextReader to use internal buffer to improve performance

-Improved JsonSerializer to cache contract/converters where possible to improve performance
-Improved JsonTextReader error message when additional JSON content found
-Fixed internal exception thrown when deserializing Decimal/DateTimeOffset/Byte lists
-Fixed various JsonTextReader bugs

10 files changed, 987 insertions, 55 deletions

diff --git a/Src/Newtonsoft.Json.Tests/JsonConvertTest.cs b/Src/Newtonsoft.Json.Tests/JsonConvertTest.cs
index 750b100..91c11b9 100644
--- a/Src/Newtonsoft.Json.Tests/JsonConvertTest.cs
+++ b/Src/Newtonsoft.Json.Tests/JsonConvertTest.cs
@@ -257,7 +257,7 @@ now brown cow?", '"', true);
     }

 

     [Test]

-    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "After parsing a value an unexpected character was encountered: t. Line 1, position 20.")]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: t. Line 1, position 19.")]

     public void TestInvalidStrings()

     {

       string orig = @"this is a string ""that has quotes"" ";

diff --git a/Src/Newtonsoft.Json.Tests/JsonTextReaderTest.cs b/Src/Newtonsoft.Json.Tests/JsonTextReaderTest.cs
index 9b3ef94..0076a54 100644
--- a/Src/Newtonsoft.Json.Tests/JsonTextReaderTest.cs
+++ b/Src/Newtonsoft.Json.Tests/JsonTextReaderTest.cs
@@ -31,6 +31,7 @@ using NUnit.Framework;
 using Newtonsoft.Json;

 using System.IO;

 using System.Xml;

+using Newtonsoft.Json.Utilities;

 

 namespace Newtonsoft.Json.Tests

 {

@@ -88,6 +89,108 @@ namespace Newtonsoft.Json.Tests
     }

 

     [Test]

+    public void ReadConstructor()

+    {

+      string json = @"{""DefaultConverter"":new Date(0, ""hi""),""MemberConverter"":""1970-01-01T00:00:00Z""}";

+

+      JsonReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.IsTrue(reader.Read());

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+      Assert.AreEqual("Date", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(0, reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual("hi", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual("MemberConverter", reader.Value);

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: ,. Line 5, position 2.")]

+    public void ParseAdditionalContent_Comma()

+    {

+      string json = @"[

+""Small"",

+""Medium"",

+""Large""

+],";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      while (reader.Read())

+      {

+      }

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: c. Line 5, position 2.")]

+    public void ParseAdditionalContent_Text()

+    {

+      string json = @"[

+""Small"",

+""Medium"",

+""Large""

+]content";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[2]);

+

+      reader.Read();

+      Assert.AreEqual(1, reader.LineNumber);

+

+      reader.Read();

+      Assert.AreEqual(2, reader.LineNumber);

+

+      reader.Read();

+      Assert.AreEqual(3, reader.LineNumber);

+

+      reader.Read();

+      Assert.AreEqual(4, reader.LineNumber);

+

+      reader.Read();

+      Assert.AreEqual(5, reader.LineNumber);

+

+      reader.Read();

+    }

+

+    [Test]

+    public void ParseAdditionalContent_Whitespace()

+    {

+      string json = @"[

+""Small"",

+""Medium"",

+""Large""

+]   

+

+";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      while (reader.Read())

+      {

+      }

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: a. Line 1, position 5.")]

+    public void ParseAdditionalContent_WhitespaceThenText()

+    {

+      string json = @"'hi' a";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      while (reader.Read())

+      {

+      }

+    }

+

+    [Test]

     public void ReadingIndented()

     {

       string input = @"{

@@ -102,6 +205,8 @@ namespace Newtonsoft.Json.Tests
 

       using (JsonTextReader jsonReader = new JsonTextReader(sr))

       {

+        jsonReader.SetCharBuffer(new char[5]);

+

         Assert.AreEqual(jsonReader.TokenType, JsonToken.None);

         Assert.AreEqual(0, jsonReader.LineNumber);

         Assert.AreEqual(0, jsonReader.LinePosition);

@@ -115,48 +220,48 @@ namespace Newtonsoft.Json.Tests
         Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

         Assert.AreEqual(jsonReader.Value, "CPU");

         Assert.AreEqual(2, jsonReader.LineNumber);

-        Assert.AreEqual(6, jsonReader.LinePosition);

+        Assert.AreEqual(7, jsonReader.LinePosition);

 

         jsonReader.Read();

-        Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

-        Assert.AreEqual(jsonReader.Value, "Intel");

+        Assert.AreEqual(JsonToken.String, jsonReader.TokenType);

+        Assert.AreEqual("Intel", jsonReader.Value);

         Assert.AreEqual(2, jsonReader.LineNumber);

-        Assert.AreEqual(14, jsonReader.LinePosition);

+        Assert.AreEqual(15, jsonReader.LinePosition);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

         Assert.AreEqual(jsonReader.Value, "Drives");

         Assert.AreEqual(3, jsonReader.LineNumber);

-        Assert.AreEqual(9, jsonReader.LinePosition);

+        Assert.AreEqual(10, jsonReader.LinePosition);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);

         Assert.AreEqual(3, jsonReader.LineNumber);

-        Assert.AreEqual(11, jsonReader.LinePosition);

+        Assert.AreEqual(12, jsonReader.LinePosition);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

         Assert.AreEqual(jsonReader.Value, "DVD read/writer");

         Assert.AreEqual(jsonReader.QuoteChar, '\'');

         Assert.AreEqual(4, jsonReader.LineNumber);

-        Assert.AreEqual(21, jsonReader.LinePosition);

+        Assert.AreEqual(22, jsonReader.LinePosition);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

         Assert.AreEqual(jsonReader.Value, "500 gigabyte hard drive");

         Assert.AreEqual(jsonReader.QuoteChar, '"');

         Assert.AreEqual(5, jsonReader.LineNumber);

-        Assert.AreEqual(29, jsonReader.LinePosition);

+        Assert.AreEqual(30, jsonReader.LinePosition);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);

         Assert.AreEqual(6, jsonReader.LineNumber);

-        Assert.AreEqual(3, jsonReader.LinePosition);

+        Assert.AreEqual(4, jsonReader.LinePosition);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);

         Assert.AreEqual(7, jsonReader.LineNumber);

-        Assert.AreEqual(1, jsonReader.LinePosition);

+        Assert.AreEqual(2, jsonReader.LinePosition);

 

         Assert.IsFalse(jsonReader.Read());

       }

@@ -165,7 +270,11 @@ namespace Newtonsoft.Json.Tests
     [Test]

     public void Depth()

     {

-      string input = "{value:'Purple\\r \\n monkey\\'s:\\tdishwasher',array:[1,2]}";

+      string input = @"{

+  value:'Purple',

+  array:[1,2],

+  subobject:{prop:1}

+}";

 

       StringReader sr = new StringReader(input);

 

@@ -183,7 +292,7 @@ namespace Newtonsoft.Json.Tests
 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

-        Assert.AreEqual(jsonReader.Value, "Purple\r \n monkey's:\tdishwasher");

+        Assert.AreEqual(jsonReader.Value, @"Purple");

         Assert.AreEqual(jsonReader.QuoteChar, '\'');

         Assert.AreEqual(1, jsonReader.Depth);

 

@@ -193,23 +302,43 @@ namespace Newtonsoft.Json.Tests
 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);

-        Assert.AreEqual(2, jsonReader.Depth);

+        Assert.AreEqual(1, jsonReader.Depth);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.Integer);

         Assert.AreEqual(1, jsonReader.Value);

-        Assert.AreEqual(3, jsonReader.Depth);

+        Assert.AreEqual(2, jsonReader.Depth);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.Integer);

         Assert.AreEqual(2, jsonReader.Value);

-        Assert.AreEqual(3, jsonReader.Depth);

+        Assert.AreEqual(2, jsonReader.Depth);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);

         Assert.AreEqual(1, jsonReader.Depth);

 

         jsonReader.Read();

+        Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

+        Assert.AreEqual(1, jsonReader.Depth);

+

+        jsonReader.Read();

+        Assert.AreEqual(jsonReader.TokenType, JsonToken.StartObject);

+        Assert.AreEqual(1, jsonReader.Depth);

+

+        jsonReader.Read();

+        Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

+        Assert.AreEqual(2, jsonReader.Depth);

+

+        jsonReader.Read();

+        Assert.AreEqual(jsonReader.TokenType, JsonToken.Integer);

+        Assert.AreEqual(2, jsonReader.Depth);

+

+        jsonReader.Read();

+        Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);

+        Assert.AreEqual(1, jsonReader.Depth);

+

+        jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);

         Assert.AreEqual(0, jsonReader.Depth);

       }

@@ -232,6 +361,154 @@ Parameter name: reader")]
     }

 

     [Test]

+    public void ReadLongString()

+    {

+      string s = new string('a', 10000);

+      JsonReader reader = new JsonTextReader(new StringReader("'" + s + "'"));

+      reader.Read();

+

+      Assert.AreEqual(s, reader.Value);

+    }

+

+    [Test]

+    public void ReadLongJsonArray()

+    {

+      int valueCount = 10000;

+      StringWriter sw = new StringWriter();

+      JsonTextWriter writer = new JsonTextWriter(sw);

+      writer.WriteStartArray();

+      for (int i = 0; i < valueCount; i++)

+      {

+        writer.WriteValue(i);

+      }

+      writer.WriteEndArray();

+

+      string json = sw.ToString();

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      Assert.IsTrue(reader.Read());

+      for (int i = 0; i < valueCount; i++)

+      {

+        Assert.IsTrue(reader.Read());

+        Assert.AreEqual(i, reader.Value);

+      }

+      Assert.IsTrue(reader.Read());

+      Assert.IsFalse(reader.Read());

+    }

+

+    [Test]

+    public void NullCharReading()

+    {

+      string json = "\0{\0'\0h\0i\0'\0:\0[\01\0,\0'\0'\0\0,\0null\0]\0,\0do\0:true\0}\0\0/*\0sd\0f\0*/\0/*\0sd\0f\0*/ \0";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Integer, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.String, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Null, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+      Assert.AreEqual("\0sd\0f\0", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+      Assert.AreEqual("\0sd\0f\0", reader.Value);

+

+      Assert.IsFalse(reader.Read());

+    }

+

+    [Test]

+    public void AppendCharsWhileReadingNull()

+    {

+      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));

+      reader.SetCharBuffer(new char[129]);

+

+      for (int i = 0; i < 15; i++)

+      {

+        reader.Read();

+      }

+

+      reader.Read();

+      Assert.AreEqual(JsonToken.Null, reader.TokenType);

+    }

+

+    [Test]

+    public void AppendCharsWhileReadingNewLine()

+    {

+      string json = @"

+{

+  ""description"": ""A person"",

+  ""type"": ""object"",

+  ""properties"":

+  {

+    ""name"": {""type"":""string""},

+    ""hobbies"": {

+      ""type"": ""array"",

+      ""items"": {""type"":""string""}

+    }

+  }

+}

+";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[129]);

+

+      for (int i = 0; i < 14; i++)

+      {

+        Assert.IsTrue(reader.Read());

+      }

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

+      Assert.AreEqual("type", reader.Value);

+    }

+

+    [Test]

     public void ReadNullTerminatorStrings()

     {

       JsonReader reader = new JsonTextReader(new StringReader("'h\0i'"));

@@ -241,10 +518,10 @@ Parameter name: reader")]
     }

 

     [Test]

-    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end while parsing unicode character. Line 1, position 7.")]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end while parsing unicode character. Line 1, position 4.")]

     public void UnexpectedEndOfHex()

     {

-      JsonReader reader = new JsonTextReader(new StringReader(@"'h\u006"));

+      JsonReader reader = new JsonTextReader(new StringReader(@"'h\u123"));

       reader.Read();

     }

 

@@ -294,6 +571,97 @@ Parameter name: reader")]
     }

 

     [Test]

+    public void ReadNewLines()

+    {

+      string newLinesText = StringUtils.CarriageReturn + StringUtils.CarriageReturnLineFeed + StringUtils.LineFeed + StringUtils.CarriageReturnLineFeed + " " + StringUtils.CarriageReturn + StringUtils.CarriageReturnLineFeed;

+

+      string json =

+        newLinesText

+        + "{" + newLinesText

+        + "'" + newLinesText

+        + "name1" + newLinesText

+        + "'" + newLinesText

+        + ":" + newLinesText

+        + "[" + newLinesText

+        + "new" + newLinesText

+        + "Date" + newLinesText

+        + "(" + newLinesText

+        + "1" + newLinesText

+        + "," + newLinesText

+        + "null" + newLinesText

+        + "/*" + newLinesText

+        + "blah comment" + newLinesText

+        + "*/" + newLinesText

+        + ")" + newLinesText

+        + "," + newLinesText

+        + "1.1111" + newLinesText

+        + "]" + newLinesText

+        + "," + newLinesText

+        + "name2" + newLinesText

+        + ":" + newLinesText

+        + "{" + newLinesText

+        + "}" + newLinesText

+        + "}" + newLinesText;

+

+      int count = 0;

+      StringReader sr = new StringReader(newLinesText);

+      while (sr.ReadLine() != null)

+      {

+        count++;

+      }

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(7, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(31, reader.LineNumber);

+      Assert.AreEqual(newLinesText + "name1" + newLinesText, reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(37, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(55, reader.LineNumber);

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+      Assert.AreEqual("Date", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(61, reader.LineNumber);

+      Assert.AreEqual(1, reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(73, reader.LineNumber);

+      Assert.AreEqual(null, reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(91, reader.LineNumber);

+      Assert.AreEqual(newLinesText + "blah comment" + newLinesText, reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(97, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(109, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(115, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(133, reader.LineNumber);

+      Assert.AreEqual("name2", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(139, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(145, reader.LineNumber);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(151, reader.LineNumber);

+    }

+

+    [Test]

     public void ParsingQuotedPropertyWithControlCharacters()

     {

       JsonReader reader = new JsonTextReader(new StringReader(@"{'hi\r\nbye':1}"));

@@ -303,7 +671,10 @@ Parameter name: reader")]
       Assert.AreEqual(@"hi

 bye", reader.Value);

       Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Integer, reader.TokenType);

+      Assert.AreEqual(1, reader.Value);

       Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

       Assert.IsFalse(reader.Read());

     }

 

@@ -361,21 +732,21 @@ bye", reader.Value);
         Assert.AreEqual(0, jsonReader.Depth);

 

         jsonReader.Read();

-        Assert.AreEqual(jsonReader.TokenType, JsonToken.StartObject);

+        Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType);

         Assert.AreEqual(0, jsonReader.Depth);

-

+        

         jsonReader.Read();

-        Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

+        Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);

         Assert.AreEqual(1, jsonReader.Depth);

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

-        Assert.AreEqual(jsonReader.Value, "Purple\r \n monkey's:\tdishwasher");

-        Assert.AreEqual(jsonReader.QuoteChar, '\'');

+        Assert.AreEqual("Purple\r \n monkey's:\tdishwasher", jsonReader.Value);

+        Assert.AreEqual('\'', jsonReader.QuoteChar);

         Assert.AreEqual(1, jsonReader.Depth);

 

         jsonReader.Read();

-        Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);

+        Assert.AreEqual(JsonToken.EndObject, jsonReader.TokenType);

         Assert.AreEqual(0, jsonReader.Depth);

       }

     }

@@ -395,12 +766,47 @@ bye", reader.Value);
     }

 

     [Test]

+    public void ReadRandomJson()

+    {

+      string json = @"[

+  true,

+  {

+    ""integer"": 99,

+    ""string"": ""how now brown cow?"",

+    ""array"": [

+      0,

+      1,

+      2,

+      3,

+      4,

+      {

+        ""decimal"": 990.00990099

+      },

+      5

+    ]

+  },

+  ""This is a string."",

+  null,

+  null

+]";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      while (reader.Read())

+      {

+        

+      }

+    }

+

+    [Test]

     public void WriteReadWrite()

     {

       StringBuilder sb = new StringBuilder();

       StringWriter sw = new StringWriter(sb);

 

-      using (JsonWriter jsonWriter = new JsonTextWriter(sw))

+      using (JsonWriter jsonWriter = new JsonTextWriter(sw)

+        {

+          Formatting = Formatting.Indented

+        })

       {

         jsonWriter.WriteStartArray();

         jsonWriter.WriteValue(true);

@@ -443,9 +849,12 @@ bye", reader.Value);
       sb = new StringBuilder();

       sw = new StringWriter(sb);

 

-      using (JsonWriter jsonWriter = new JsonTextWriter(sw))

+      using (JsonWriter jsonWriter = new JsonTextWriter(sw)

+        {

+          Formatting = Formatting.Indented

+        })

       {

-        serializer.Serialize(sw, jsonObject);

+        serializer.Serialize(jsonWriter, jsonObject);

       }

 

       Assert.AreEqual(json, sb.ToString());

@@ -513,6 +922,7 @@ bye", reader.Value);
       string json = @"[""\u003c"",""\u5f20""]";

 

       JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[2]);

 

       reader.Read();

       Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

@@ -609,9 +1019,7 @@ bye", reader.Value);
     {

       string json = @"{

     ""A"" : true,

-    ""B"" ""hello"", // Notice the colon is missing

-    ""C"" : ""bye""

-}";

+    ""B"" """;

 

       JsonTextReader reader = new JsonTextReader(new StringReader(json));

 

@@ -668,11 +1076,118 @@ bye", reader.Value);
     }

 

     [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected character encountered while parsing value: }. Line 1, position 1.")]

+    public void ReadBadCharInArray()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"[}"));

+

+      reader.Read();

+      reader.Read();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end when reading decimal: Line 0, position 0.")]

+    public void ReadAsDecimalNoContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@""));

+

+      reader.ReadAsDecimal();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end when reading bytes: Line 0, position 0.")]

+    public void ReadAsBytesNoContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@""));

+

+      reader.ReadAsBytes();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end when reading bytes: Line 1, position 1.")]

+    public void ReadAsBytesNoContentWrappedObject()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"{"));

+

+      reader.ReadAsBytes();

+    }

+

+#if !NET20

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end when reading date: Line 0, position 0.")]

+    public void ReadAsDateTimeOffsetNoContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@""));

+

+      reader.ReadAsDateTimeOffset();

+    }

+#endif

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected token when reading decimal: StartConstructor. Line 1, position 9.")]

+    public void ReadAsDecimalBadContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"new Date()"));

+

+      reader.ReadAsDecimal();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected token when reading bytes: StartConstructor. Line 1, position 9.")]

+    public void ReadAsBytesBadContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"new Date()"));

+

+      reader.ReadAsBytes();

+    }

+

+#if !NET20

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected token when reading date: StartConstructor. Line 1, position 9.")]

+    public void ReadAsDateTimeOffsetBadContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"new Date()"));

+

+      reader.ReadAsDateTimeOffset();

+    }

+#endif

+

+    [Test]

+    public void ReadAsBytesIntegerArrayWithComments()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"[/*hi*/1/*hi*/,2/*hi*/]"));

+

+      byte[] data = reader.ReadAsBytes();

+      Assert.AreEqual(2, data.Length);

+      Assert.AreEqual(1, data[0]);

+      Assert.AreEqual(2, data[1]);

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end when reading bytes: Line 1, position 2.")]

+    public void ReadAsBytesIntegerArrayWithNoEnd()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"[1"));

+

+      reader.ReadAsBytes();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected token when reading bytes: Float. Line 1, position 4.")]

+    public void ReadAsBytesArrayWithBadContent()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"[1.0]"));

+

+      reader.ReadAsBytes();

+    }

+

+    [Test]

     public void ReadUnicode()

     {

       string json = @"{""Message"":""Hi,I\u0092ve send you smth""}";

 

       JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[5]);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

@@ -802,6 +1317,46 @@ bye", reader.Value);
     }

 

     [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Error parsing null value. Line 0, position 0.")]

+    public void MatchWithInsufficentCharacters()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"nul"));

+      reader.Read();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Error parsing null value. Line 0, position 0.")]

+    public void MatchWithWrongCharacters()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"nulz"));

+      reader.Read();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Error parsing null value. Line 1, position 4.")]

+    public void MatchWithNoTrailingSeperator()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"nullz"));

+      reader.Read();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end while parsing comment.")]

+    public void UnclosedComment()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"/* sdf"));

+      reader.Read();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Error parsing comment. Expected: *, got s. Line 1, position 1.")]

+    public void BadCommentStart()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader(@"/sdf"));

+      reader.Read();

+    }

+

+    [Test]

     public void ReadAsDateTimeOffsetIsoDate()

     {

       string json = @"{""Offset"":""2011-08-01T21:25Z""}";

@@ -918,5 +1473,343 @@ bye", reader.Value);
       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

     }

+

+    [Test]

+    public void ReadBufferOnControlChar()

+    {

+      string json = @"[

+  {

+    ""Name"": ""Jim"",

+    ""BirthDate"": ""\/Date(978048000000)\/"",

+    ""LastModified"": ""\/Date(978048000000)\/""

+  },

+  {

+    ""Name"": ""Jim"",

+    ""BirthDate"": ""\/Date(978048000000)\/"",

+    ""LastModified"": ""\/Date(978048000000)\/""

+  }

+]";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[5]);

+      for (int i = 0; i < 13; i++)

+      {

+        reader.Read();

+      }

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(new DateTime(631136448000000000), reader.Value);

+    }

+

+    [Test]

+    public void ReadBufferOnEndComment()

+    {

+      string json = @"/*comment*/ { /*comment*/

+        ""Name"": /*comment*/ ""Apple"" /*comment*/, /*comment*/

+        ""ExpiryDate"": ""\/Date(1230422400000)\/"",

+        ""Price"": 3.99,

+        ""Sizes"": /*comment*/ [ /*comment*/

+          ""Small"", /*comment*/

+          ""Medium"" /*comment*/,

+          /*comment*/ ""Large""

+        /*comment*/ ] /*comment*/

+      } /*comment*/";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[5]);

+

+      for (int i = 0; i < 26; i++)

+      {

+        Assert.IsTrue(reader.Read());

+      }

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsFalse(reader.Read());

+    }

+

+    [Test]

+    public void ParseNullStringConstructor()

+    {

+      string json = "new Date\0()";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+      reader.SetCharBuffer(new char[7]);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual("Date", reader.Value);

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

+    }

+

+    [Test]

+    public void ParseLineFeedDelimitedConstructor()

+    {

+      string json = "new Date\n()";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual("Date", reader.Value);

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

+    }

+

+    [Test]

+    public void ParseArrayWithMissingValues()

+    {

+      string json = "[,,, \n\r\n \0   \r  , ,    ]";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

+    }

+

+    [Test]

+    public void ParseBooleanWithNoExtraContent()

+    {

+      string json = "[true ";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.IsTrue(reader.Read());

+      Assert.IsFalse(reader.Read());

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected end while parsing constructor.")]

+    public void ParseConstructorWithUnexpectedEnd()

+    {

+      string json = "new Dat";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      reader.Read();

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected character while parsing constructor: !. Line 1, position 9.")]

+    public void ParseConstructorWithUnexpectedCharacter()

+    {

+      string json = "new Date !";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      reader.Read();

+    }

+

+    [Test]

+    public void ParseObjectWithNoEnd()

+    {

+      string json = "{hi:1, ";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.IsTrue(reader.Read());

+      Assert.IsTrue(reader.Read());

+      Assert.IsFalse(reader.Read());

+    }

+

+    [Test]

+    public void ParseEmptyArray()

+    {

+      string json = "[]";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

+    }

+

+    [Test]

+    public void ParseEmptyObject()

+    {

+      string json = "{}";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Error parsing boolean value. Line 1, position 4.")]

+    public void ParseIncompleteCommentSeperator()

+    {

+      JsonTextReader reader = new JsonTextReader(new StringReader("true/"));

+

+      reader.Read();

+    }

+

+    [Test]

+    public void ParseEmptyConstructor()

+    {

+      string json = "new Date()";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

+    }

+

+    [Test]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected character while parsing constructor: ,. Line 1, position 8.")]

+    public void ParseConstructorWithBadCharacter()

+    {

+      string json = "new Date,()";

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+    }

+

+    [Test]

+    public void ParseContentDelimitedByNonStandardWhitespace()

+    {

+      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 StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

+      

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

+      

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

+      

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

+

+      Assert.IsFalse(reader.Read());

+    }

+    

+    [Test]

+    public void ReadContentDelimitedByComments()

+    {

+      string json = @"/*comment*/{/*comment*/Name:/*comment*/true/*comment*/,/*comment*/

+        ""ExpiryDate"":/*comment*/new

+" + StringUtils.LineFeed +

+@"Date

+(/*comment*/null/*comment*/),

+        ""Price"": 3.99,

+        ""Sizes"":/*comment*/[/*comment*/

+          ""Small""/*comment*/]/*comment*/}/*comment*/";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

+      Assert.AreEqual("Name", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

+      Assert.AreEqual(true, reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

+      Assert.AreEqual("ExpiryDate", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

+      Assert.AreEqual(5, reader.LineNumber);

+      Assert.AreEqual("Date", reader.Value);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Null, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.Comment, reader.TokenType);

+

+      Assert.IsTrue(reader.Read());

+      Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

+    }

+

+    [Test]

+    public void ParseOctalNumber()

+    {

+      string json = @"010";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      reader.ReadAsDecimal();

+      Assert.AreEqual(JsonToken.Float, reader.TokenType);

+      Assert.AreEqual(8m, reader.Value);

+    }

+

+    [Test]

+    public void ParseHexNumber()

+    {

+      string json = @"0x20";

+

+      JsonTextReader reader = new JsonTextReader(new StringReader(json));

+

+      reader.ReadAsDecimal();

+      Assert.AreEqual(JsonToken.Float, reader.TokenType);

+      Assert.AreEqual(32m, reader.Value);

+    }

   }

 }
\ No newline at end of file
diff --git a/Src/Newtonsoft.Json.Tests/JsonValidatingReaderTests.cs b/Src/Newtonsoft.Json.Tests/JsonValidatingReaderTests.cs
index 432cf9b..a0ec484 100644
--- a/Src/Newtonsoft.Json.Tests/JsonValidatingReaderTests.cs
+++ b/Src/Newtonsoft.Json.Tests/JsonValidatingReaderTests.cs
@@ -371,7 +371,7 @@ namespace Newtonsoft.Json.Tests
 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.Integer, reader.TokenType);

-      Assert.AreEqual(@"Value 3 is not defined in enum. Line 1, position 7.", validationEventArgs.Message);

+      Assert.AreEqual(@"Value 3 is not defined in enum. Line 1, position 6.", validationEventArgs.Message);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

@@ -457,7 +457,7 @@ namespace Newtonsoft.Json.Tests
 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.Float, reader.TokenType);

-      Assert.AreEqual(@"Value 3.0 is not defined in enum. Line 1, position 13.", validationEventArgs.Message);

+      Assert.AreEqual(@"Value 3.0 is not defined in enum. Line 1, position 12.", validationEventArgs.Message);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

@@ -496,7 +496,7 @@ namespace Newtonsoft.Json.Tests
 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.Float, reader.TokenType);

-      Assert.AreEqual(@"Float 4.001 is not evenly divisible by 0.1. Line 1, position 15.", validationEventArgs.Message);

+      Assert.AreEqual(@"Float 4.001 is not evenly divisible by 0.1. Line 1, position 14.", validationEventArgs.Message);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

@@ -723,7 +723,7 @@ namespace Newtonsoft.Json.Tests
 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.Float, reader.TokenType);

-      Assert.AreEqual(@"Type Float is disallowed. Line 1, position 11.", validationEventArgs.Message);

+      Assert.AreEqual(@"Type Float is disallowed. Line 1, position 10.", validationEventArgs.Message);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

@@ -1029,7 +1029,7 @@ namespace Newtonsoft.Json.Tests
 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.Integer, reader.TokenType);

-      Assert.AreEqual("Invalid type. Expected String but got Integer. Line 1, position 3.", validationEventArgs.Message);

+      Assert.AreEqual("Invalid type. Expected String but got Integer. Line 1, position 2.", validationEventArgs.Message);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.String, reader.TokenType);

@@ -1097,7 +1097,7 @@ namespace Newtonsoft.Json.Tests
 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

-      Assert.AreEqual("Property 'hey' has not been defined and the schema does not allow additional properties. Line 5, position 8.", validationEventArgs.Message);

+      Assert.AreEqual("Property 'hey' has not been defined and the schema does not allow additional properties. Line 5, position 9.", validationEventArgs.Message);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.String, reader.TokenType);

@@ -1198,7 +1198,7 @@ namespace Newtonsoft.Json.Tests
       Assert.AreEqual(JsonToken.String, reader.TokenType);

       Assert.AreEqual("secasecasecasecaseca", reader.Value.ToString());

       Assert.AreEqual(1, errors.Count);

-      Assert.AreEqual("String 'secasecasecasecaseca' exceeds maximum length of 10. Line 3, position 41.", errors[0]);

+      Assert.AreEqual("String 'secasecasecasecaseca' exceeds maximum length of 10. Line 3, position 42.", errors[0]);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

@@ -1218,9 +1218,9 @@ namespace Newtonsoft.Json.Tests
       Assert.AreEqual(JsonToken.String, reader.TokenType);

       Assert.AreEqual("aaa", reader.Value.ToString());

       Assert.AreEqual(4, errors.Count);

-      Assert.AreEqual("String 'aaa' is less than minimum length of 7. Line 5, position 39.", errors[1]);

-      Assert.AreEqual("String 'aaa' does not match regex pattern 'hi'. Line 5, position 39.", errors[2]);

-      Assert.AreEqual("String 'aaa' does not match regex pattern 'hi2u'. Line 5, position 39.", errors[3]);

+      Assert.AreEqual("String 'aaa' is less than minimum length of 7. Line 5, position 40.", errors[1]);

+      Assert.AreEqual("String 'aaa' does not match regex pattern 'hi'. Line 5, position 40.", errors[2]);

+      Assert.AreEqual("String 'aaa' does not match regex pattern 'hi2u'. Line 5, position 40.", errors[3]);

 

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

@@ -1231,7 +1231,7 @@ namespace Newtonsoft.Json.Tests
       Assert.AreEqual(JsonToken.String, reader.TokenType);

       Assert.AreEqual("three", reader.Value.ToString());

       Assert.AreEqual(5, errors.Count);

-      Assert.AreEqual("String 'three' is less than minimum length of 6. Line 6, position 24.", errors[4]);

+      Assert.AreEqual("String 'three' is less than minimum length of 6. Line 6, position 25.", errors[4]);

       

       Assert.IsTrue(reader.Read());

       Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

diff --git a/Src/Newtonsoft.Json.Tests/Linq/JArrayTests.cs b/Src/Newtonsoft.Json.Tests/Linq/JArrayTests.cs
index 030a8fd..a25c7fc 100644
--- a/Src/Newtonsoft.Json.Tests/Linq/JArrayTests.cs
+++ b/Src/Newtonsoft.Json.Tests/Linq/JArrayTests.cs
@@ -450,7 +450,7 @@ Parameter name: index")]
     }

 

     [Test]

-    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected state: Finished. Line 5, position 3.")]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: ,. Line 5, position 2.")]

     public void ParseAdditionalContent()

     {

       string json = @"[

diff --git a/Src/Newtonsoft.Json.Tests/Linq/JObjectTests.cs b/Src/Newtonsoft.Json.Tests/Linq/JObjectTests.cs
index 959daec..c8060c0 100644
--- a/Src/Newtonsoft.Json.Tests/Linq/JObjectTests.cs
+++ b/Src/Newtonsoft.Json.Tests/Linq/JObjectTests.cs
@@ -1626,7 +1626,7 @@ Parameter name: arrayIndex")]
     }

 

     [Test]

-    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected state: Finished. Line 10, position 3.")]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: ,. Line 10, position 2.")]

     public void ParseAdditionalContent()

     {

       string json = @"{

diff --git a/Src/Newtonsoft.Json.Tests/Linq/JTokenReaderTest.cs b/Src/Newtonsoft.Json.Tests/Linq/JTokenReaderTest.cs
index 9a0df42..aee77d7 100644
--- a/Src/Newtonsoft.Json.Tests/Linq/JTokenReaderTest.cs
+++ b/Src/Newtonsoft.Json.Tests/Linq/JTokenReaderTest.cs
@@ -147,41 +147,41 @@ namespace Newtonsoft.Json.Tests.Linq
         Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

         Assert.AreEqual(jsonReader.Value, "CPU");

         Assert.AreEqual(2, lineInfo.LineNumber);

-        Assert.AreEqual(6, lineInfo.LinePosition);

+        Assert.AreEqual(7, lineInfo.LinePosition);

         Assert.AreEqual(true, lineInfo.HasLineInfo());

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

         Assert.AreEqual(jsonReader.Value, "Intel");

         Assert.AreEqual(2, lineInfo.LineNumber);

-        Assert.AreEqual(14, lineInfo.LinePosition);

+        Assert.AreEqual(15, lineInfo.LinePosition);

         Assert.AreEqual(true, lineInfo.HasLineInfo());

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

         Assert.AreEqual(jsonReader.Value, "Drives");

         Assert.AreEqual(3, lineInfo.LineNumber);

-        Assert.AreEqual(9, lineInfo.LinePosition);

+        Assert.AreEqual(10, lineInfo.LinePosition);

         Assert.AreEqual(true, lineInfo.HasLineInfo());

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);

         Assert.AreEqual(3, lineInfo.LineNumber);

-        Assert.AreEqual(11, lineInfo.LinePosition);

+        Assert.AreEqual(12, lineInfo.LinePosition);

         Assert.AreEqual(true, lineInfo.HasLineInfo());

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

         Assert.AreEqual(jsonReader.Value, "DVD read/writer");

         Assert.AreEqual(4, lineInfo.LineNumber);

-        Assert.AreEqual(21, lineInfo.LinePosition);

+        Assert.AreEqual(22, lineInfo.LinePosition);

         Assert.AreEqual(true, lineInfo.HasLineInfo());

 

         jsonReader.Read();

         Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

         Assert.AreEqual(jsonReader.Value, "500 gigabyte hard drive");

         Assert.AreEqual(5, lineInfo.LineNumber);

-        Assert.AreEqual(29, lineInfo.LinePosition);

+        Assert.AreEqual(30, lineInfo.LinePosition);

         Assert.AreEqual(true, lineInfo.HasLineInfo());

 

         jsonReader.Read();

diff --git a/Src/Newtonsoft.Json.Tests/Linq/JTokenTests.cs b/Src/Newtonsoft.Json.Tests/Linq/JTokenTests.cs
index a5ceea0..f578e51 100644
--- a/Src/Newtonsoft.Json.Tests/Linq/JTokenTests.cs
+++ b/Src/Newtonsoft.Json.Tests/Linq/JTokenTests.cs
@@ -741,14 +741,14 @@ namespace Newtonsoft.Json.Tests.Linq
     }

 

     [Test]

-    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Unexpected state: Finished. Line 5, position 3.")]

+    [ExpectedException(typeof(JsonReaderException), ExpectedMessage = "Additional text encountered after finished reading JSON content: ,. Line 5, position 2.")]

     public void ParseAdditionalContent()

     {

       string json = @"[

 ""Small"",

 ""Medium"",

 ""Large""

-], 987987";

+],";

 

       JToken.Parse(json);

     }

diff --git a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs
index e24a613..91e51fd 100644
--- a/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs
+++ b/Src/Newtonsoft.Json.Tests/Properties/AssemblyInfo.cs
@@ -64,7 +64,7 @@ using System.Runtime.InteropServices;
 //

 // You can specify all the values or you can default the Revision and Build Numbers 

 // by using the '*' as shown below:

-[assembly: AssemblyVersion("4.0.3.0")]

+[assembly: AssemblyVersion("4.0.5.0")]

 #if !PocketPC

-[assembly: AssemblyFileVersion("4.0.3.14319")]

+[assembly: AssemblyFileVersion("4.0.5.14516")]

 #endif

diff --git a/Src/Newtonsoft.Json.Tests/Schema/ExtensionsTests.cs b/Src/Newtonsoft.Json.Tests/Schema/ExtensionsTests.cs
index 2d02d97..1314733 100644
--- a/Src/Newtonsoft.Json.Tests/Schema/ExtensionsTests.cs
+++ b/Src/Newtonsoft.Json.Tests/Schema/ExtensionsTests.cs
@@ -108,7 +108,7 @@ namespace Newtonsoft.Json.Tests.Schema
       List<string> errors = new List<string>();

       o.Validate(schema, (sender, args) => errors.Add(args.Message));

 

-      Assert.AreEqual("Invalid type. Expected String but got Integer. Line 1, position 9.", errors[0]);

+      Assert.AreEqual("Invalid type. Expected String but got Integer. Line 1, position 8.", errors[0]);

       Assert.AreEqual(1, errors.Count);

     }

 

diff --git a/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs b/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs
index fd394f2..14df3b6 100644
--- a/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs
+++ b/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs
@@ -3263,7 +3263,7 @@ keyword such as type of business.""
           Converters = new List<JsonConverter> {new StringAppenderConverter()}

         });

 

-      Assert.AreEqual(p.Name, "Existing,Appended");

+      Assert.AreEqual("Existing,Appended", p.Name);

     }

 

     [Test]

@@ -5073,6 +5073,45 @@ keyword such as type of business.""
       }

     }

 #endif

+

+    [Test]

+    public void ReadForTypeHackFixDecimal()

+    {

+      IList<decimal> d1 = new List<decimal> { 1.1m};

+

+      string json = JsonConvert.SerializeObject(d1);

+

+      IList<decimal> d2 = JsonConvert.DeserializeObject<IList<decimal>>(json);

+

+      Assert.AreEqual(d1.Count, d2.Count);

+      Assert.AreEqual(d1[0], d2[0]);

+    }

+

+    [Test]

+    public void ReadForTypeHackFixDateTimeOffset()

+    {

+      IList<DateTimeOffset?> d1 = new List<DateTimeOffset?> { null };

+

+      string json = JsonConvert.SerializeObject(d1);

+

+      IList<DateTimeOffset?> d2 = JsonConvert.DeserializeObject<IList<DateTimeOffset?>>(json);

+

+      Assert.AreEqual(d1.Count, d2.Count);

+      Assert.AreEqual(d1[0], d2[0]);

+    }

+

+    [Test]

+    public void ReadForTypeHackFixByteArray()

+    {

+      IList<byte[]> d1 = new List<byte[]> { null };

+

+      string json = JsonConvert.SerializeObject(d1);

+

+      IList<byte[]> d2 = JsonConvert.DeserializeObject<IList<byte[]>>(json);

+

+      Assert.AreEqual(d1.Count, d2.Count);

+      Assert.AreEqual(d1[0], d2[0]);

+    }

   }

 

   public class DecimalTestClass