Improve code coverage for System.Text.Json with targeted unit tests

Co-authored-by: stephentoub <[email protected]>

Author: Copilot

src/libraries/System.Text.Json/tests/System.Text.Json.Tests/BitStackTests.cs

@@ -23,7 +23,7 @@ public static void SetResetFirstBit()
             Assert.Equal(0, bitStack.CurrentDepth);
             bitStack.SetFirstBit();
             Assert.Equal(1, bitStack.CurrentDepth);
-            Assert.False(bitStack.Pop());
+            Assert.True(bitStack.Pop());
             Assert.Equal(0, bitStack.CurrentDepth);
 
             bitStack = default;
@@ -37,14 +37,89 @@ public static void SetResetFirstBit()
             Assert.Equal(0, bitStack.CurrentDepth);
             bitStack.SetFirstBit();
             Assert.Equal(1, bitStack.CurrentDepth);
-            Assert.False(bitStack.Pop());
+            Assert.True(bitStack.Pop());
             Assert.Equal(0, bitStack.CurrentDepth);
             bitStack.ResetFirstBit();
             Assert.Equal(1, bitStack.CurrentDepth);
             Assert.False(bitStack.Pop());
             Assert.Equal(0, bitStack.CurrentDepth);
         }
 
+        [Fact]
+        public static void PeekTest()
+        {
+            BitStack bitStack = default;
+            
+            bitStack.PushTrue();
+            Assert.True(bitStack.Peek());
+            Assert.Equal(1, bitStack.CurrentDepth);
+            
+            bitStack.PushFalse();
+            Assert.False(bitStack.Peek());
+            Assert.Equal(2, bitStack.CurrentDepth);
+            
+            bitStack.PushTrue();
+            Assert.True(bitStack.Peek());
+            Assert.Equal(3, bitStack.CurrentDepth);
+            
+            Assert.True(bitStack.Pop());
+            Assert.False(bitStack.Peek());
+            Assert.Equal(2, bitStack.CurrentDepth);
+            
+            Assert.False(bitStack.Pop());
+            Assert.True(bitStack.Peek());
+            Assert.Equal(1, bitStack.CurrentDepth);
+            
+            Assert.True(bitStack.Pop());
+            Assert.Equal(0, bitStack.CurrentDepth);
+        }
+
+        [Fact]
+        public static void PeekAtDepth64()
+        {
+            BitStack bitStack = default;
+            
+            for (int i = 0; i < 63; i++)
+            {
+                bitStack.PushFalse();
+            }
+            
+            bitStack.PushTrue();
+            Assert.Equal(64, bitStack.CurrentDepth);
+            Assert.True(bitStack.Peek());
+            
+            Assert.True(bitStack.Pop());
+            Assert.Equal(63, bitStack.CurrentDepth);
+            Assert.False(bitStack.Peek());
+        }
+
+        [Fact]
+        public static void PeekBeyondAllocationFreeDepth()
+        {
+            BitStack bitStack = default;
+            
+            for (int i = 0; i < 64; i++)
+            {
+                bitStack.PushFalse();
+            }
+            
+            bitStack.PushTrue();
+            Assert.Equal(65, bitStack.CurrentDepth);
+            Assert.True(bitStack.Peek());
+            
+            bitStack.PushFalse();
+            Assert.Equal(66, bitStack.CurrentDepth);
+            Assert.False(bitStack.Peek());
+            
+            Assert.False(bitStack.Pop());
+            Assert.True(bitStack.Peek());
+            Assert.Equal(65, bitStack.CurrentDepth);
+            
+            Assert.True(bitStack.Pop());
+            Assert.False(bitStack.Peek());
+            Assert.Equal(64, bitStack.CurrentDepth);
+        }
+
         [Theory]
         [InlineData(32)]
         [InlineData(64)]

src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonEncodedTextTests.cs

@@ -539,5 +539,108 @@ public static void CustomEncoderClass()
             text = JsonEncodedText.Encode(message, new CustomEncoderAllowingPlusSign());
             Assert.Equal("a+", text.Value);
         }
+
+        [Fact]
+        public static void EncodeEmptySpan()
+        {
+            JsonEncodedText text = JsonEncodedText.Encode(ReadOnlySpan<char>.Empty);
+            Assert.True(text.EncodedUtf8Bytes.IsEmpty);
+            Assert.Equal("", text.Value);
+            Assert.Equal("", text.ToString());
+            Assert.Equal(0, text.GetHashCode());
+        }
+
+        [Fact]
+        public static void EncodeEmptyUtf8Span()
+        {
+            JsonEncodedText text = JsonEncodedText.Encode(ReadOnlySpan<byte>.Empty);
+            Assert.True(text.EncodedUtf8Bytes.IsEmpty);
+            Assert.Equal("", text.Value);
+            Assert.Equal("", text.ToString());
+            Assert.Equal(0, text.GetHashCode());
+        }
+
+        [Fact]
+        public static void EncodedUtf8BytesProperty()
+        {
+            string message = "Hello";
+            JsonEncodedText text = JsonEncodedText.Encode(message);
+            
+            ReadOnlySpan<byte> bytes = text.EncodedUtf8Bytes;
+            Assert.False(bytes.IsEmpty);
+            Assert.Equal(Encoding.UTF8.GetBytes(message), bytes.ToArray());
+        }
+
+        [Fact]
+        public static void EqualsWithDifferentObjectType()
+        {
+            JsonEncodedText text = JsonEncodedText.Encode("test");
+            
+            Assert.False(text.Equals("test"));
+            Assert.False(text.Equals(42));
+            Assert.False(text.Equals(new object()));
+        }
+
+        [Fact]
+        public static void HashCodeConsistency()
+        {
+            string message = "consistent";
+            JsonEncodedText text1 = JsonEncodedText.Encode(message);
+            JsonEncodedText text2 = JsonEncodedText.Encode(message);
+            
+            int hash1 = text1.GetHashCode();
+            int hash2 = text2.GetHashCode();
+            int hash1Again = text1.GetHashCode();
+            
+            Assert.Equal(hash1, hash2);
+            Assert.Equal(hash1, hash1Again);
+        }
+
+        [Fact]
+        public static void EncodeWithEscapingRequired()
+        {
+            string message = "line1\nline2";
+            JsonEncodedText text = JsonEncodedText.Encode(message);
+            
+            Assert.Contains("\\n", text.Value);
+            Assert.NotEqual(message, text.Value);
+        }
+
+        [Fact]
+        public static void EncodeUtf8WithEscapingRequired()
+        {
+            byte[] utf8Message = Encoding.UTF8.GetBytes("test\"value");
+            JsonEncodedText text = JsonEncodedText.Encode(utf8Message);
+            
+            Assert.Contains("\\u0022", text.Value);
+        }
+
+        [Theory]
+        [InlineData("abc")]
+        [InlineData("Hello World")]
+        [InlineData("123")]
+        public static void EncodeSpanMatchesString(string message)
+        {
+            JsonEncodedText textFromString = JsonEncodedText.Encode(message);
+            JsonEncodedText textFromSpan = JsonEncodedText.Encode(message.AsSpan());
+            
+            Assert.Equal(textFromString.Value, textFromSpan.Value);
+            Assert.True(textFromString.Equals(textFromSpan));
+            Assert.Equal(textFromString.GetHashCode(), textFromSpan.GetHashCode());
+        }
+
+        [Theory]
+        [InlineData("abc")]
+        [InlineData("Hello World")]
+        [InlineData("123")]
+        public static void EncodeUtf8MatchesString(string message)
+        {
+            JsonEncodedText textFromString = JsonEncodedText.Encode(message);
+            JsonEncodedText textFromUtf8 = JsonEncodedText.Encode(Encoding.UTF8.GetBytes(message));
+            
+            Assert.Equal(textFromString.Value, textFromUtf8.Value);
+            Assert.True(textFromString.Equals(textFromUtf8));
+            Assert.Equal(textFromString.GetHashCode(), textFromUtf8.GetHashCode());
+        }
     }
 }