Add tests for JsonObject

Fix a bug where renaming a property to the same name would remove the property.

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/LightJson/JsonObjectTests.cs

@@ -0,0 +1,112 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Test.LightJson
+{
+    using System;
+    using System.Collections.Generic;
+    using global::LightJson;
+    using Xunit;
+    using IEnumerable = System.Collections.IEnumerable;
+
+    public class JsonObjectTests
+    {
+        [Fact]
+        public void TestCount()
+        {
+            var obj = new JsonObject();
+            Assert.Equal(0, obj.Count);
+
+            obj["x"] = "value";
+            Assert.Equal(1, obj.Count);
+
+            obj["y"] = "value";
+            Assert.Equal(2, obj.Count);
+
+            obj["x"] = "value2";
+            Assert.Equal(2, obj.Count);
+
+            Assert.True(obj.Remove("x"));
+            Assert.Equal(1, obj.Count);
+
+            Assert.False(obj.Remove("x"));
+            Assert.Equal(1, obj.Count);
+
+            obj["z"] = "value3";
+            Assert.Equal(2, obj.Count);
+
+            Assert.Same(obj, obj.Clear());
+            Assert.Equal(0, obj.Count);
+        }
+
+        [Fact]
+        public void TestAdd()
+        {
+            var obj = new JsonObject();
+            Assert.Equal(JsonValue.Null, obj["x"]);
+            Assert.False(obj.ContainsKey("x"));
+
+            Assert.Same(obj, obj.Add("x"));
+            Assert.Equal(JsonValue.Null, obj["x"]);
+            Assert.True(obj.ContainsKey("x"));
+        }
+
+        [Fact]
+        public void TestEnumerator()
+        {
+            var obj = new JsonObject();
+            obj["x"] = "x1";
+            obj["y"] = "y1";
+
+            foreach (var value in obj)
+            {
+                Assert.Equal(typeof(KeyValuePair<string, JsonValue>), StaticType(value));
+                Assert.Equal(value.Value, obj[value.Key]);
+            }
+
+            IEnumerable<JsonValue> genericEnumerable = obj;
+            foreach (var value in genericEnumerable)
+            {
+                Assert.True(obj.Contains(value));
+            }
+
+            IEnumerable legacyEnumerable = obj;
+            foreach (var value in legacyEnumerable)
+            {
+                Assert.IsType<KeyValuePair<string, JsonValue>>(value);
+                Assert.True(obj.Contains(((KeyValuePair<string, JsonValue>)value).Value));
+            }
+        }
+
+        [Fact]
+        public void TestRename()
+        {
+            var obj = new JsonObject { ["x"] = "value1", ["y"] = "value2" };
+            Assert.Equal(2, obj.Count);
+
+            var value = obj["x"].AsString;
+            Assert.False(obj.ContainsKey("z"));
+            Assert.Same(obj, obj.Rename("x", "z"));
+            Assert.Same(value, obj["z"].AsString);
+            Assert.False(obj.ContainsKey("x"));
+            Assert.Equal(2, obj.Count);
+
+            // Renaming can overwrite a value
+            Assert.Same(obj, obj.Rename("z", "y"));
+            Assert.Same(value, obj["y"].AsString);
+            Assert.Equal(1, obj.Count);
+
+            // Renaming to the same name does nothing
+            Assert.Same(obj, obj.Rename("y", "y"));
+            Assert.Same(value, obj["y"].AsString);
+            Assert.Equal(1, obj.Count);
+
+            // Renaming a non-existent element is not a problem, and does not overwrite the target
+            Assert.Same(obj, obj.Rename("bogus", "y"));
+            Assert.Equal(1, obj.Count);
+            Assert.Same(value, obj["y"].AsString);
+        }
+
+        private static Type StaticType<T>(T value) => typeof(T);
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers.Test/StyleCop.Analyzers.Test.csproj

@@ -235,6 +235,7 @@
     <Compile Include="LayoutRules\SA1518UnitTests.cs" />
     <Compile Include="LayoutRules\SA1519UnitTests.cs" />
     <Compile Include="LayoutRules\SA1520UnitTests.cs" />
+    <Compile Include="LightJson\JsonObjectTests.cs" />
     <Compile Include="LightJson\JsonReaderTests.cs" />
     <Compile Include="LightJson\JsonValueTests.cs" />
     <Compile Include="Lightup\AccessorDeclarationSyntaxExtensionsTests.cs" />

StyleCop.Analyzers/StyleCop.Analyzers/LightJson/JsonObject.cs

@@ -5,6 +5,7 @@ namespace LightJson
 {
     using System.Collections.Generic;
     using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
 
     /// <summary>
     /// Represents a key-value pair collection of JsonValue objects.
@@ -121,6 +122,12 @@ public JsonObject Clear()
         /// <returns>Returns this JsonObject.</returns>
         public JsonObject Rename(string oldKey, string newKey)
         {
+            if (oldKey == newKey)
+            {
+                // Renaming to the same name just does nothing
+                return this;
+            }
+
             JsonValue value;
 
             if (this.properties.TryGetValue(oldKey, out value))
@@ -179,6 +186,7 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
             return this.GetEnumerator();
         }
 
+        [ExcludeFromCodeCoverage]
         private class JsonObjectDebugView
         {
             private JsonObject jsonObject;