Add tests for JsonReader

* Remove unreachable code in ReadBoolean
* Fix several error positions

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/LightJson/Serialization/JsonReaderTests.cs

@@ -3,6 +3,8 @@
 
 namespace StyleCop.Analyzers.Test.LightJson.Serialization
 {
+    using System;
+    using System.IO;
     using global::LightJson;
     using global::LightJson.Serialization;
     using Xunit;
@@ -24,5 +26,70 @@ public void TestDuplicateKeys()
         {
             Assert.ThrowsAny<JsonParseException>(() => JsonValue.Parse("{ \"x\": \"value\", \"x\": \"value\" }"));
         }
+
+        [Fact]
+        public void TestParse()
+        {
+            Assert.Equal("true", JsonReader.Parse("true").AsString);
+
+            using (var reader = new StringReader("true"))
+            {
+                Assert.Equal("true", JsonReader.Parse(reader).AsString);
+            }
+
+            Assert.Throws<ArgumentNullException>("source", () => JsonReader.Parse(default(string)));
+            Assert.Throws<ArgumentNullException>("reader", () => JsonReader.Parse(default(TextReader)));
+        }
+
+        [Fact]
+        public void TestNumbers()
+        {
+            Assert.Equal(0, JsonReader.Parse("0").AsInteger);
+            Assert.Equal(0, JsonReader.Parse("-0").AsInteger);
+            Assert.Equal(-1, JsonReader.Parse("-1").AsInteger);
+            Assert.Equal(-1.0, JsonReader.Parse("-1.0").AsNumber);
+            Assert.Equal(-1e1, JsonReader.Parse("-1e1").AsNumber);
+            Assert.Equal(-1E1, JsonReader.Parse("-1E1").AsNumber);
+            Assert.Equal(-1E+1, JsonReader.Parse("-1E+1").AsNumber);
+            Assert.Equal(-10E-1, JsonReader.Parse("-10E-1").AsNumber);
+        }
+
+        [Fact]
+        public void TestEscapeSequences()
+        {
+            Assert.Equal("\"", JsonReader.Parse("\"\\\"\"").AsString);
+            Assert.Equal("\\", JsonReader.Parse("\"\\\\\"").AsString);
+            Assert.Equal("/", JsonReader.Parse("\"\\/\"").AsString);
+            Assert.Equal("\b", JsonReader.Parse("\"\\b\"").AsString);
+            Assert.Equal("\f", JsonReader.Parse("\"\\f\"").AsString);
+            Assert.Equal("\n", JsonReader.Parse("\"\\n\"").AsString);
+            Assert.Equal("\r", JsonReader.Parse("\"\\r\"").AsString);
+            Assert.Equal("\t", JsonReader.Parse("\"\\t\"").AsString);
+            Assert.Equal("\u0123\u4567\u89AB\uCDEF", JsonReader.Parse("\"\\u0123\\u4567\\u89AB\\uCDEF\"").AsString);
+
+            var ex = Assert.Throws<JsonParseException>(() => JsonReader.Parse("\"\\x\""));
+            Assert.Equal(JsonParseException.ErrorType.InvalidOrUnexpectedCharacter, ex.Type);
+            Assert.Equal(0, ex.Position.Line);
+            Assert.Equal(2, ex.Position.Column);
+
+            ex = Assert.Throws<JsonParseException>(() => JsonReader.Parse("\"\\u11GA\""));
+            Assert.Equal(JsonParseException.ErrorType.InvalidOrUnexpectedCharacter, ex.Type);
+            Assert.Equal(0, ex.Position.Line);
+            Assert.Equal(5, ex.Position.Column);
+
+            ex = Assert.Throws<JsonParseException>(() => JsonReader.Parse("\"\r\""));
+            Assert.Equal(JsonParseException.ErrorType.InvalidOrUnexpectedCharacter, ex.Type);
+            Assert.Equal(0, ex.Position.Line);
+            Assert.Equal(1, ex.Position.Column);
+        }
+
+        [Fact]
+        public void TestArrayMissingComma()
+        {
+            var ex = Assert.ThrowsAny<JsonParseException>(() => JsonReader.Parse("[ 1 2 ]"));
+            Assert.Equal(JsonParseException.ErrorType.InvalidOrUnexpectedCharacter, ex.Type);
+            Assert.Equal(0, ex.Position.Line);
+            Assert.Equal(4, ex.Position.Column);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/LightJson/Serialization/JsonReader.cs

@@ -30,7 +30,7 @@ public static JsonValue Parse(TextReader reader)
         {
             if (reader == null)
             {
-                throw new ArgumentNullException("reader");
+                throw new ArgumentNullException(nameof(reader));
             }
 
             return new JsonReader(reader).Parse();
@@ -45,12 +45,12 @@ public static JsonValue Parse(string source)
         {
             if (source == null)
             {
-                throw new ArgumentNullException("source");
+                throw new ArgumentNullException(nameof(source));
             }
 
             using (var reader = new StringReader(source))
             {
-                return new JsonReader(reader).Parse();
+                return Parse(reader);
             }
         }
 
@@ -112,14 +112,9 @@ private JsonValue ReadBoolean()
                     this.scanner.Assert("true");
                     return true;
 
-                case 'f':
+                default:
                     this.scanner.Assert("false");
                     return false;
-
-                default:
-                    throw new JsonParseException(
-                        ErrorType.InvalidOrUnexpectedCharacter,
-                        this.scanner.Position);
             }
         }
 
@@ -191,10 +186,12 @@ private string ReadString()
 
             while (true)
             {
+                var errorPosition = this.scanner.Position;
                 var c = this.scanner.Read();
 
                 if (c == '\\')
                 {
+                    errorPosition = this.scanner.Position;
                     c = this.scanner.Read();
 
                     switch (char.ToLower(c))
@@ -225,7 +222,7 @@ private string ReadString()
                         default:
                             throw new JsonParseException(
                                 ErrorType.InvalidOrUnexpectedCharacter,
-                                this.scanner.Position);
+                                errorPosition);
                     }
                 }
                 else if (c == '"')
@@ -238,7 +235,7 @@ private string ReadString()
                     {
                         throw new JsonParseException(
                             ErrorType.InvalidOrUnexpectedCharacter,
-                            this.scanner.Position);
+                            errorPosition);
                     }
                     else
                     {
@@ -252,6 +249,7 @@ private string ReadString()
 
         private int ReadHexDigit()
         {
+            var errorPosition = this.scanner.Position;
             switch (char.ToUpper(this.scanner.Read()))
             {
                 case '0':
@@ -305,7 +303,7 @@ private int ReadHexDigit()
                 default:
                     throw new JsonParseException(
                         ErrorType.InvalidOrUnexpectedCharacter,
-                        this.scanner.Position);
+                        errorPosition);
             }
         }
 
@@ -342,13 +340,14 @@ private JsonObject ReadObject(JsonObject jsonObject)
                 {
                     this.scanner.SkipWhitespace();
 
+                    var errorPosition = this.scanner.Position;
                     var key = this.ReadJsonKey();
 
                     if (jsonObject.ContainsKey(key))
                     {
                         throw new JsonParseException(
                             ErrorType.DuplicateObjectKeys,
-                            this.scanner.Position);
+                            errorPosition);
                     }
 
                     this.scanner.SkipWhitespace();
@@ -363,6 +362,7 @@ private JsonObject ReadObject(JsonObject jsonObject)
 
                     this.scanner.SkipWhitespace();
 
+                    errorPosition = this.scanner.Position;
                     var next = this.scanner.Read();
                     if (next == ',')
                     {
@@ -386,7 +386,7 @@ private JsonObject ReadObject(JsonObject jsonObject)
                     {
                         throw new JsonParseException(
                             ErrorType.InvalidOrUnexpectedCharacter,
-                            this.scanner.Position);
+                            errorPosition);
                     }
                 }
             }
@@ -421,6 +421,7 @@ private JsonArray ReadArray(JsonArray jsonArray)
 
                     this.scanner.SkipWhitespace();
 
+                    var errorPosition = this.scanner.Position;
                     var next = this.scanner.Read();
                     if (next == ',')
                     {
@@ -444,7 +445,7 @@ private JsonArray ReadArray(JsonArray jsonArray)
                     {
                         throw new JsonParseException(
                             ErrorType.InvalidOrUnexpectedCharacter,
-                            this.scanner.Position);
+                            errorPosition);
                     }
                 }
             }