diff --git a/src/System.Text.Json/ref/System.Text.Json.cs b/src/System.Text.Json/ref/System.Text.Json.cs
index 1cd6b06e9056..6164b2372c0c 100644
--- a/src/System.Text.Json/ref/System.Text.Json.cs
+++ b/src/System.Text.Json/ref/System.Text.Json.cs
@@ -12,6 +12,7 @@ public partial class JsonArray : System.Text.Json.JsonNode, System.Collections.G
         public JsonArray() { }
         public JsonArray(System.Collections.Generic.IEnumerable<bool> values) { }
         public JsonArray(System.Collections.Generic.IEnumerable<byte> values) { }
+        public JsonArray(System.Collections.Generic.IEnumerable<decimal> values) { }
         public JsonArray(System.Collections.Generic.IEnumerable<double> values) { }
         public JsonArray(System.Collections.Generic.IEnumerable<short> values) { }
         public JsonArray(System.Collections.Generic.IEnumerable<int> values) { }
@@ -32,6 +33,7 @@ public JsonArray(System.Collections.Generic.IEnumerable<ulong> values) { }
         public System.Text.Json.JsonNode this[int idx] { get { throw null; } set { } }
         public void Add(bool value) { }
         public void Add(byte value) { }
+        public void Add(decimal value) { }
         public void Add(double value) { }
         public void Add(short value) { }
         public void Add(int value) { }
@@ -50,6 +52,7 @@ public void Add(ulong value) { }
         public void Clear() { }
         public bool Contains(bool value) { throw null; }
         public bool Contains(byte value) { throw null; }
+        public bool Contains(decimal value) { throw null; }
         public bool Contains(double value) { throw null; }
         public bool Contains(short value) { throw null; }
         public bool Contains(int value) { throw null; }
@@ -69,6 +72,7 @@ public void Clear() { }
         public int IndexOf(System.Text.Json.JsonNode item) { throw null; }
         public void Insert(int index, bool item) { }
         public void Insert(int index, byte item) { }
+        public void Insert(int index, decimal item) { }
         public void Insert(int index, double item) { }
         public void Insert(int index, short item) { }
         public void Insert(int index, int item) { }
@@ -90,14 +94,17 @@ public void RemoveAt(int index) { }
         void System.Collections.Generic.ICollection<System.Text.Json.JsonNode>.CopyTo(System.Text.Json.JsonNode[] array, int arrayIndex) { }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
     }
-    public partial class JsonBoolean : System.Text.Json.JsonNode
+    public partial class JsonBoolean : System.Text.Json.JsonNode, System.IEquatable<System.Text.Json.JsonBoolean>
     {
         public JsonBoolean() { }
         public JsonBoolean(bool value) { }
         public bool Value { get { throw null; } set { } }
         public override bool Equals(object obj) { throw null; }
+        public bool Equals(System.Text.Json.JsonBoolean other) { throw null; }
         public override int GetHashCode() { throw null; }
+        public static bool operator ==(System.Text.Json.JsonBoolean left, System.Text.Json.JsonBoolean right) { throw null; }
         public static implicit operator System.Text.Json.JsonBoolean (bool value) { throw null; }
+        public static bool operator !=(System.Text.Json.JsonBoolean left, System.Text.Json.JsonBoolean right) { throw null; }
     }
     public enum JsonCommentHandling : byte
     {
@@ -264,10 +271,11 @@ internal JsonNode() { }
         public static System.Text.Json.JsonNode Parse(string json) { throw null; }
         public static bool TryGetNode(System.Text.Json.JsonElement jsonElement, out System.Text.Json.JsonNode jsonNode) { throw null; }
     }
-    public partial class JsonNumber : System.Text.Json.JsonNode
+    public partial class JsonNumber : System.Text.Json.JsonNode, System.IEquatable<System.Text.Json.JsonNumber>
     {
         public JsonNumber() { }
         public JsonNumber(byte value) { }
+        public JsonNumber(decimal value) { }
         public JsonNumber(double value) { }
         public JsonNumber(short value) { }
         public JsonNumber(int value) { }
@@ -283,7 +291,9 @@ public JsonNumber(uint value) { }
         [System.CLSCompliantAttribute(false)]
         public JsonNumber(ulong value) { }
         public override bool Equals(object obj) { throw null; }
+        public bool Equals(System.Text.Json.JsonNumber other) { throw null; }
         public byte GetByte() { throw null; }
+        public decimal GetDecimal() { throw null; }
         public double GetDouble() { throw null; }
         public override int GetHashCode() { throw null; }
         public short GetInt16() { throw null; }
@@ -292,14 +302,15 @@ public JsonNumber(ulong value) { }
         [System.CLSCompliantAttribute(false)]
         public sbyte GetSByte() { throw null; }
         public float GetSingle() { throw null; }
-        public string GetString() { throw null; }
         [System.CLSCompliantAttribute(false)]
         public ushort GetUInt16() { throw null; }
         [System.CLSCompliantAttribute(false)]
         public uint GetUInt32() { throw null; }
         [System.CLSCompliantAttribute(false)]
         public ulong GetUInt64() { throw null; }
+        public static bool operator ==(System.Text.Json.JsonNumber left, System.Text.Json.JsonNumber right) { throw null; }
         public static implicit operator System.Text.Json.JsonNumber (byte value) { throw null; }
+        public static implicit operator System.Text.Json.JsonNumber (decimal value) { throw null; }
         public static implicit operator System.Text.Json.JsonNumber (double value) { throw null; }
         public static implicit operator System.Text.Json.JsonNumber (short value) { throw null; }
         public static implicit operator System.Text.Json.JsonNumber (int value) { throw null; }
@@ -313,22 +324,26 @@ public JsonNumber(ulong value) { }
         public static implicit operator System.Text.Json.JsonNumber (uint value) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static implicit operator System.Text.Json.JsonNumber (ulong value) { throw null; }
+        public static bool operator !=(System.Text.Json.JsonNumber left, System.Text.Json.JsonNumber right) { throw null; }
         public void SetByte(byte value) { }
+        public void SetDecimal(decimal value) { }
         public void SetDouble(double value) { }
+        public void SetFormattedValue(string value) { }
         public void SetInt16(short value) { }
         public void SetInt32(int value) { }
         public void SetInt64(long value) { }
         [System.CLSCompliantAttribute(false)]
         public void SetSByte(sbyte value) { }
         public void SetSingle(float value) { }
-        public void SetString(string value) { }
         [System.CLSCompliantAttribute(false)]
         public void SetUInt16(ushort value) { }
         [System.CLSCompliantAttribute(false)]
         public void SetUInt32(uint value) { }
         [System.CLSCompliantAttribute(false)]
         public void SetUInt64(ulong value) { }
+        public override string ToString() { throw null; }
         public bool TryGetByte(out byte value) { throw null; }
+        public bool TryGetDecimal(out decimal value) { throw null; }
         public bool TryGetDouble(out double value) { throw null; }
         public bool TryGetInt16(out short value) { throw null; }
         public bool TryGetInt32(out int value) { throw null; }
@@ -354,6 +369,7 @@ public void Add(System.Collections.Generic.KeyValuePair<string, System.Text.Json
         public void Add(string propertyName, bool propertyValue) { }
         public void Add(string propertyName, byte propertyValue) { }
         public void Add(string propertyName, System.Collections.Generic.IEnumerable<System.Text.Json.JsonNode> propertyValue) { }
+        public void Add(string propertyName, decimal propertyValue) { }
         public void Add(string propertyName, double propertyValue) { }
         public void Add(string propertyName, short propertyValue) { }
         public void Add(string propertyName, int propertyValue) { }
@@ -445,14 +461,17 @@ public JsonSerializerOptions() { }
         public bool WriteIndented { get { throw null; } set { } }
         public System.Text.Json.Serialization.JsonConverter GetConverter(System.Type typeToConvert) { throw null; }
     }
-    public partial class JsonString : System.Text.Json.JsonNode
+    public partial class JsonString : System.Text.Json.JsonNode, System.IEquatable<System.Text.Json.JsonString>
     {
         public JsonString() { }
         public JsonString(string value) { }
         public string Value { get { throw null; } set { } }
         public override bool Equals(object obj) { throw null; }
+        public bool Equals(System.Text.Json.JsonString other) { throw null; }
         public override int GetHashCode() { throw null; }
+        public static bool operator ==(System.Text.Json.JsonString left, System.Text.Json.JsonString right) { throw null; }
         public static implicit operator System.Text.Json.JsonString (string value) { throw null; }
+        public static bool operator !=(System.Text.Json.JsonString left, System.Text.Json.JsonString right) { throw null; }
     }
     public enum JsonTokenType : byte
     {
diff --git a/src/System.Text.Json/src/System/Text/Json/Node/JsonArray.cs b/src/System.Text.Json/src/System/Text/Json/Node/JsonArray.cs
index c2abffde5a74..d3cd46ca3873 100644
--- a/src/System.Text.Json/src/System/Text/Json/Node/JsonArray.cs
+++ b/src/System.Text.Json/src/System/Text/Json/Node/JsonArray.cs
@@ -30,6 +30,7 @@ public JsonArray(IEnumerable<ushort> values) { }
         public JsonArray(IEnumerable<uint> values) { }
         [CLSCompliant(false)]
         public JsonArray(IEnumerable<ulong> values) { }
+        public JsonArray(IEnumerable<decimal> values) { }
 
         public JsonNode this[int idx] { get => throw null; set => throw null; }
 
@@ -50,6 +51,7 @@ public void Add(ushort value) { }
         public void Add(uint value) { }
         [CLSCompliant(false)]
         public void Add(ulong value) { }
+        public void Add(decimal value) { }
 
         public void Insert(int index, JsonNode item) { throw null; }
         public void Insert(int index, string item) { throw null; }
@@ -68,6 +70,7 @@ public void Add(ulong value) { }
         public void Insert(int index, uint item) { throw null; }
         [CLSCompliant(false)]
         public void Insert(int index, ulong item) { throw null; }
+        public void Insert(int index, decimal item) { throw null; }
 
         public bool Contains(JsonNode value) { throw null; }
         public bool Contains(string value) { throw null; }
@@ -86,6 +89,7 @@ public void Add(ulong value) { }
         public bool Contains(uint value) { throw null; }
         [CLSCompliant(false)]
         public bool Contains(ulong value) { throw null; }
+        public bool Contains(decimal value) { throw null; }
 
         public int Count => throw null;
         public bool IsReadOnly => throw null;
diff --git a/src/System.Text.Json/src/System/Text/Json/Node/JsonBoolean.cs b/src/System.Text.Json/src/System/Text/Json/Node/JsonBoolean.cs
index c18f85b01b32..c0768d810fdb 100644
--- a/src/System.Text.Json/src/System/Text/Json/Node/JsonBoolean.cs
+++ b/src/System.Text.Json/src/System/Text/Json/Node/JsonBoolean.cs
@@ -7,7 +7,7 @@
 
 namespace System.Text.Json
 {
-    public partial class JsonBoolean : JsonNode
+    public partial class JsonBoolean : JsonNode, IEquatable<JsonBoolean>
     {
         public JsonBoolean() { }
         public JsonBoolean(bool value) { }
@@ -18,7 +18,11 @@ public JsonBoolean(bool value) { }
 
         public override bool Equals(object obj) { throw null; }
         public override int GetHashCode() { throw null; }
+
+        public bool Equals(JsonBoolean other) { throw null; }
+
+        public static bool operator ==(JsonBoolean left, JsonBoolean right) => throw null;
+        public static bool operator !=(JsonBoolean left, JsonBoolean right) => throw null;
     }
 }
-
 #pragma warning restore CS1591
diff --git a/src/System.Text.Json/src/System/Text/Json/Node/JsonNumber.cs b/src/System.Text.Json/src/System/Text/Json/Node/JsonNumber.cs
index 7a9fd6337015..adae60a4f28c 100644
--- a/src/System.Text.Json/src/System/Text/Json/Node/JsonNumber.cs
+++ b/src/System.Text.Json/src/System/Text/Json/Node/JsonNumber.cs
@@ -5,91 +5,171 @@
 // for now disabling error caused by not adding documentation to methods 
 #pragma warning disable CS1591
 
+using System.Buffers;
+
 namespace System.Text.Json
 {
-    public partial class JsonNumber : JsonNode
+    public partial class JsonNumber : JsonNode, IEquatable<JsonNumber>
     {
-        public JsonNumber() { }
-        public JsonNumber(string value) { }
-        public JsonNumber(byte value) { }
-        public JsonNumber(short value) { }
-        public JsonNumber(int value) { }
-        public JsonNumber(long value) { }
-        public JsonNumber(float value) { }
-        public JsonNumber(double value) { }
-        [CLSCompliant(false)]
-        public JsonNumber(sbyte value) { }
-        [CLSCompliant(false)]
-        public JsonNumber(ushort value) { }
-        [CLSCompliant(false)]
-        public JsonNumber(uint value) { }
-        [CLSCompliant(false)]
-        public JsonNumber(ulong value) { }
+        private string _value;
 
-        public string GetString() { throw null; }
-        public byte GetByte() { throw null; }
-        public int GetInt32() { throw null; }
-        public short GetInt16() { throw null; }
-        public long GetInt64() { throw null; }
-        public float GetSingle() { throw null; }
-        public double GetDouble() { throw null; }
-        [CLSCompliant(false)]
-        public sbyte GetSByte() { throw null; }
-        [CLSCompliant(false)]
-        public ushort GetUInt16() { throw null; }
-        [CLSCompliant(false)]
-        public uint GetUInt32() { throw null; }
-        [CLSCompliant(false)]
-        public ulong GetUInt64() { throw null; }
+        public JsonNumber() => _value = "0";
 
-        public bool TryGetByte(out byte value) { throw null; }
-        public bool TryGetInt32(out int value) { throw null; }
-        public bool TryGetInt16(out short value) { throw null; }
-        public bool TryGetInt64(out long value) { throw null; }
-        public bool TryGetSingle(out float value) { throw null; }
-        public bool TryGetDouble(out double value) { throw null; }
-        [CLSCompliant(false)]
-        public bool TryGetSByte(out sbyte value) { throw null; }
-        [CLSCompliant(false)]
-        public bool TryGetUInt16(out ushort value) { throw null; }
-        [CLSCompliant(false)]
-        public bool TryGetUInt32(out uint value) { throw null; }
-        [CLSCompliant(false)]
-        public bool TryGetUInt64(out ulong value) { throw null; }
+        public JsonNumber(string value) => SetFormattedValue(value);
+        
+        public JsonNumber(byte value) => SetByte(value);
+        
+        public JsonNumber(short value) => SetInt16(value);
+        
+        public JsonNumber(int value) => SetInt32(value);
+        
+        public JsonNumber(long value) => SetInt64(value);
+        
+        public JsonNumber(float value) => SetSingle(value);
+        
+        public JsonNumber(double value) => SetDouble(value);
+        
+        [CLSCompliant(false)]
+        public JsonNumber(sbyte value) => SetSByte(value);
+        
+        [CLSCompliant(false)]
+        public JsonNumber(ushort value) => SetUInt16(value);
+        
+        [CLSCompliant(false)]
+        public JsonNumber(uint value) => SetUInt32(value);
+        
+        [CLSCompliant(false)]
+        public JsonNumber(ulong value) => SetUInt64(value);
 
-        public void SetString(string value) { }
-        public void SetByte(byte value) { }
-        public void SetInt32(int value) { }
-        public void SetInt16(short value) { }
-        public void SetInt64(long value) { }
-        public void SetSingle(float value) { }
-        public void SetDouble(double value) { }
-        [CLSCompliant(false)]
-        public void SetSByte(sbyte value) { }
-        [CLSCompliant(false)]
-        public void SetUInt16(ushort value) { }
-        [CLSCompliant(false)]
-        public void SetUInt32(uint value) { }
-        [CLSCompliant(false)]
-        public void SetUInt64(ulong value) { }
+        public JsonNumber(decimal value) => SetDecimal(value);
+
+        public override string ToString() => _value; 
+        
+        public byte GetByte() => byte.Parse(_value);
+        
+        public short GetInt16() => short.Parse(_value);
+        
+        public int GetInt32() => int.Parse(_value);
+        
+        public long GetInt64() => long.Parse(_value);
+        
+        public float GetSingle() => float.Parse(_value);
+        
+        public double GetDouble() => double.Parse(_value);
+        
+        [CLSCompliant(false)]
+        public sbyte GetSByte() => sbyte.Parse(_value);
+        
+        [CLSCompliant(false)]
+        public ushort GetUInt16() => ushort.Parse(_value);
+        
+        [CLSCompliant(false)]
+        public uint GetUInt32() => uint.Parse(_value);
+        
+        [CLSCompliant(false)]
+        public ulong GetUInt64() => ulong.Parse(_value);
+
+        public decimal GetDecimal() => decimal.Parse(_value);
+
+        public bool TryGetByte(out byte value) => byte.TryParse(_value, out value);
+
+        public bool TryGetInt16(out short value) => short.TryParse(_value, out value);
+
+        public bool TryGetInt32(out int value) => int.TryParse(_value, out value);
+
+        public bool TryGetInt64(out long value) => long.TryParse(_value, out value);
+
+        public bool TryGetSingle(out float value) => float.TryParse(_value, out value);
+
+        public bool TryGetDouble(out double value) => double.TryParse(_value, out value);
 
-        public static implicit operator JsonNumber(byte value) { throw null; }
-        public static implicit operator JsonNumber(int value) { throw null; }
-        public static implicit operator JsonNumber(short value) { throw null; }
-        public static implicit operator JsonNumber(long value) { throw null; }
-        public static implicit operator JsonNumber(float value) { throw null; }
-        public static implicit operator JsonNumber(double value) { throw null; }
         [CLSCompliant(false)]
-        public static implicit operator JsonNumber(sbyte value) { throw null; }
+        public bool TryGetSByte(out sbyte value) => sbyte.TryParse(_value, out value);
+
         [CLSCompliant(false)]
-        public static implicit operator JsonNumber(ushort value) { throw null; }
+        public bool TryGetUInt16(out ushort value) => ushort.TryParse(_value, out value);
+
         [CLSCompliant(false)]
-        public static implicit operator JsonNumber(uint value) { throw null; }
+        public bool TryGetUInt32(out uint value) => uint.TryParse(_value, out value);
+
         [CLSCompliant(false)]
-        public static implicit operator JsonNumber(ulong value) { throw null; }
+        public bool TryGetUInt64(out ulong value) => ulong.TryParse(_value, out value);
+
+        public bool TryGetDecimal(out decimal value) => decimal.TryParse(_value, out value);
+
+
+        public void SetFormattedValue(string value)
+        {
+            if (value == null)
+                throw new ArgumentNullException(nameof(value));
+            if (value.Length == 0)
+                throw new ArgumentException("Expected number, but instead got empty string.", nameof(value));
+            
+            JsonWriterHelper.ValidateNumber(Encoding.UTF8.GetBytes(value).AsSpan());
+            _value = value;
+        }
+
+        public void SetByte(byte value) => _value = value.ToString();
+        
+        public void SetInt16(short value) => _value = value.ToString();
+        
+        public void SetInt32(int value) => _value = value.ToString();
+        
+        public void SetInt64(long value) => _value = value.ToString();
+        
+        public void SetSingle(float value) => _value = value.ToString();
+        
+        public void SetDouble(double value) => _value = value.ToString();
+        
+        [CLSCompliant(false)]
+        public void SetSByte(sbyte value) => _value = value.ToString();
+        
+        [CLSCompliant(false)]
+        public void SetUInt16(ushort value) => _value = value.ToString();
+        
+        [CLSCompliant(false)]
+        public void SetUInt32(uint value) => _value = value.ToString();
+        
+        [CLSCompliant(false)]
+        public void SetUInt64(ulong value) => _value = value.ToString();
+
+        public void SetDecimal(decimal value) => _value = value.ToString();
+
+        public static implicit operator JsonNumber(byte value) => new JsonNumber(value);
+        
+        public static implicit operator JsonNumber(int value) => new JsonNumber(value);
+        
+        public static implicit operator JsonNumber(short value) => new JsonNumber(value);
+        
+        public static implicit operator JsonNumber(long value) => new JsonNumber(value);
+        
+        public static implicit operator JsonNumber(float value) => new JsonNumber(value);
+        
+        public static implicit operator JsonNumber(double value) => new JsonNumber(value);
+        
+        [CLSCompliant(false)]
+        public static implicit operator JsonNumber(sbyte value) => new JsonNumber(value);
+        
+        [CLSCompliant(false)]
+        public static implicit operator JsonNumber(ushort value) => new JsonNumber(value);
+        
+        [CLSCompliant(false)]
+        public static implicit operator JsonNumber(uint value) => new JsonNumber(value);
+        
+        [CLSCompliant(false)]
+        public static implicit operator JsonNumber(ulong value) => new JsonNumber(value);
+
+        public static implicit operator JsonNumber(decimal value) => new JsonNumber(value);
+
+        public override bool Equals(object obj) => obj is JsonNumber number && _value == number._value;
+
+        public override int GetHashCode() => _value.GetHashCode();
+
+        public bool Equals(JsonNumber other) => _value == other._value;
 
-        public override bool Equals(object obj) { throw null; }
-        public override int GetHashCode() { throw null; }
+        public static bool operator ==(JsonNumber left, JsonNumber right) => left._value == right._value;
+        
+        public static bool operator !=(JsonNumber left, JsonNumber right) => left._value != right._value;
     }
 }
 
diff --git a/src/System.Text.Json/src/System/Text/Json/Node/JsonObject.cs b/src/System.Text.Json/src/System/Text/Json/Node/JsonObject.cs
index 5955e1fd3eea..0c285632c84d 100644
--- a/src/System.Text.Json/src/System/Text/Json/Node/JsonObject.cs
+++ b/src/System.Text.Json/src/System/Text/Json/Node/JsonObject.cs
@@ -37,6 +37,7 @@ public void Add(string propertyName, ushort propertyValue) { }
         public void Add(string propertyName, uint propertyValue) { }
         [CLSCompliant(false)]
         public void Add(string propertyName, ulong propertyValue) { }
+        public void Add(string propertyName, decimal propertyValue) { }
         public void Add(string propertyName, IEnumerable<JsonNode> propertyValue) { }
         public void AddRange(IEnumerable<KeyValuePair<string, JsonNode>> jsonProperties) { }
 
diff --git a/src/System.Text.Json/src/System/Text/Json/Node/JsonString.cs b/src/System.Text.Json/src/System/Text/Json/Node/JsonString.cs
index 9c993375209c..99c701c50ece 100644
--- a/src/System.Text.Json/src/System/Text/Json/Node/JsonString.cs
+++ b/src/System.Text.Json/src/System/Text/Json/Node/JsonString.cs
@@ -7,7 +7,7 @@
 
 namespace System.Text.Json
 {
-    public partial class JsonString : JsonNode
+    public partial class JsonString : JsonNode, IEquatable<JsonString>
     {
         public JsonString() { }
         public JsonString(string value) { }
@@ -18,6 +18,11 @@ public JsonString(string value) { }
 
         public override bool Equals(object obj) { throw null; }
         public override int GetHashCode() { throw null; }
+
+        public bool Equals(JsonString other) { throw null; }
+
+        public static bool operator ==(JsonString left, JsonString right) => throw null;
+        public static bool operator !=(JsonString left, JsonString right) => throw null;
     }
 }
 
diff --git a/src/System.Text.Json/tests/System.Text.Json.Tests.csproj b/src/System.Text.Json/tests/System.Text.Json.Tests.csproj
index 14b23aa2f3ac..7a9dcd5ce226 100644
--- a/src/System.Text.Json/tests/System.Text.Json.Tests.csproj
+++ b/src/System.Text.Json/tests/System.Text.Json.Tests.csproj
@@ -107,6 +107,7 @@
     <Compile Include="WritableJsonApiTests.TestTransformations.cs" />
     <Compile Include="WritableJsonApiTests.cs" />
     <Compile Include="WritableJsonApiTests.TestData.cs" />
+    <Compile Include="WritableJsonApiTests.JsonNumberUnitTests.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsNetFx)' == 'true'">
     <Compile Include="$(CommonPath)\System\Buffers\ArrayBufferWriter.cs">
diff --git a/src/System.Text.Json/tests/WritableJsonApiTests.JsonNumberUnitTests.cs b/src/System.Text.Json/tests/WritableJsonApiTests.JsonNumberUnitTests.cs
new file mode 100644
index 000000000000..2f32a32588da
--- /dev/null
+++ b/src/System.Text.Json/tests/WritableJsonApiTests.JsonNumberUnitTests.cs
@@ -0,0 +1,473 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+
+namespace System.Text.Json
+{
+    public static partial class WritableJsonApiTests
+    {
+        [Theory]
+        [InlineData(-456)]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(long.MaxValue)]
+        [InlineData(2.3)]
+        [InlineData(-17.009)]
+        [InlineData(3.14f)]
+        [InlineData(0x2A)]
+        [InlineData(0b_0110_1010)]
+        [InlineData("1e400")]
+        [InlineData("1e+100000002")]
+        [InlineData("184467440737095516150.184467440737095516150")]
+        public static void TestJsonNumberConstructor(object value)
+        {
+            // should not throw any exceptions:
+            _ = new JsonNumber(value as dynamic);
+        }
+
+        [Fact]
+        public static void TestDefaultCtor()
+        {
+            var jsonNumber = new JsonNumber();
+            Assert.Equal(0, jsonNumber.GetInt32());
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(255)]
+        public static void TestByte(byte value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetByte(value);
+            Assert.Equal(value, jsonNumber.GetByte());
+            Assert.True(jsonNumber.TryGetByte(out byte result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(-17)]
+        [InlineData(17)]
+        [InlineData(short.MinValue)]
+        [InlineData(short.MaxValue)]
+        public static void TestShort(short value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetInt16(value);
+            Assert.Equal(value, jsonNumber.GetInt16());
+            Assert.True(jsonNumber.TryGetInt16(out short result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(-17)]
+        [InlineData(17)]
+        [InlineData(int.MinValue)]
+        [InlineData(int.MaxValue)]
+        public static void TestInt(int value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetInt32(value);
+            Assert.Equal(value, jsonNumber.GetInt32());
+            Assert.True(jsonNumber.TryGetInt32(out int result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(-17)]
+        [InlineData(17)]
+        [InlineData(long.MinValue)]
+        [InlineData(long.MaxValue)]
+        public static void TestLong(long value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetInt64(value);
+            Assert.Equal(value, jsonNumber.GetInt64());
+            Assert.True(jsonNumber.TryGetInt64(out long result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(-17)]
+        [InlineData(3.14)]
+        [InlineData(-15.5)]
+        [InlineData(float.MinValue)]
+        [InlineData(float.MaxValue)]
+        public static void TestFloat(float value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetSingle(value);
+            Assert.Equal(value, jsonNumber.GetSingle());
+            Assert.True(jsonNumber.TryGetSingle(out float result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(-17)]
+        [InlineData(3.14)]
+        [InlineData(-15.5)]
+        [InlineData(double.MinValue)]
+        [InlineData(double.MaxValue)]
+        public static void TestDouble(double value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetDouble(value);
+            Assert.Equal(value, jsonNumber.GetDouble());
+            Assert.True(jsonNumber.TryGetDouble(out double result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(-17)]
+        [InlineData(sbyte.MinValue)]
+        [InlineData(sbyte.MaxValue)]
+        public static void TestSbyte(sbyte value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetSByte(value);
+            Assert.Equal(value, jsonNumber.GetSByte());
+            Assert.True(jsonNumber.TryGetSByte(out sbyte result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(ushort.MaxValue)]
+        public static void TestUInt16(ushort value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetUInt16(value);
+            Assert.Equal(value, jsonNumber.GetUInt16());
+            Assert.True(jsonNumber.TryGetUInt16(out ushort result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(uint.MaxValue)]
+        public static void TestUInt32(uint value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetUInt32(value);
+            Assert.Equal(value, jsonNumber.GetUInt32());
+            Assert.True(jsonNumber.TryGetUInt32(out uint result));
+            Assert.Equal(value, result);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(17)]
+        [InlineData(ulong.MaxValue)]
+        public static void TestUInt64(ulong value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetUInt64(value);
+            Assert.Equal(value, jsonNumber.GetUInt64());
+            Assert.True(jsonNumber.TryGetUInt64(out ulong result));
+            Assert.Equal(value, result);
+        }
+
+        [Fact]
+        public static void TestDecimal()
+        {
+            var decimalValue = decimal.MaxValue;
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetDecimal(decimalValue);
+            Assert.Equal(decimalValue, jsonNumber.GetDecimal());
+            Assert.True(jsonNumber.TryGetDecimal(out decimal result));
+            Assert.Equal(decimalValue, result);
+        }
+
+        [Theory]
+        [InlineData("3.14")]
+        [InlineData("-17")]
+        [InlineData("0")]
+        [InlineData("189")]
+        [InlineData("1e400")]
+        [InlineData("1e+100000002")]
+        [InlineData("184467440737095516150.184467440737095516150")]
+        public static void TestString(string value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetFormattedValue(value);
+            Assert.Equal(value, jsonNumber.ToString());
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData("3,14")]
+        [InlineData("this is not a number")]
+        [InlineData("NAN")]
+        [InlineData("0.")]
+        [InlineData("008")]
+        [InlineData("0e")]
+        [InlineData("5e")]
+        [InlineData("5a")]
+        [InlineData("0.1e")]
+        [InlineData("-01")]
+        [InlineData("10.5e")]
+        [InlineData("10.5e-")]
+        [InlineData("10.5e+")]
+        [InlineData("10.5e-0.2")]
+        [InlineData(" 6")]
+        [InlineData("6 ")]
+        [InlineData(" 6 ")]
+        [InlineData("+0")]
+        [InlineData("+1")]
+        public static void TestInvalidString(string value)
+        {
+            Assert.Throws<ArgumentException>(() => new JsonNumber(value));
+        }
+
+        [Fact]
+        public static void TestNullString()
+        {
+            Assert.Throws<ArgumentNullException>(() => new JsonNumber(null));
+        }
+
+        [Fact]
+        public static void TestIntFromString()
+        {
+            var jsonNumber = new JsonNumber("145");
+            Assert.Equal(145, jsonNumber.GetInt32());
+        }
+
+        [Fact]
+        public static void TestUpcasts()
+        {
+            byte value = 17;
+            var jsonNumber = new JsonNumber(value);
+
+            // Getting other types should also succeed:
+            Assert.Equal(value, jsonNumber.GetInt16());
+            Assert.True(jsonNumber.TryGetInt16(out short shortResult));
+            Assert.Equal(value, shortResult);
+
+            Assert.Equal(value, jsonNumber.GetInt32());
+            Assert.True(jsonNumber.TryGetInt32(out int intResult));
+            Assert.Equal(value, intResult);
+
+            Assert.Equal(value, jsonNumber.GetInt64());
+            Assert.True(jsonNumber.TryGetInt64(out long longResult));
+            Assert.Equal(value, longResult);
+
+            Assert.Equal(value, jsonNumber.GetSingle());
+            Assert.True(jsonNumber.TryGetSingle(out float floatResult));
+            Assert.Equal(value, floatResult);
+
+            Assert.Equal(value, jsonNumber.GetDouble());
+            Assert.True(jsonNumber.TryGetDouble(out double doubleResult));
+            Assert.Equal(value, doubleResult);
+
+            Assert.Equal(value, (byte)jsonNumber.GetSByte());
+            Assert.True(jsonNumber.TryGetSByte(out sbyte sbyteResult));
+            Assert.Equal(value, (byte)sbyteResult);
+
+            Assert.Equal(value, jsonNumber.GetUInt16());
+            Assert.True(jsonNumber.TryGetUInt16(out ushort ushortResult));
+            Assert.Equal(value, ushortResult);
+
+            Assert.Equal(value, jsonNumber.GetUInt32());
+            Assert.True(jsonNumber.TryGetUInt32(out uint uintResult));
+            Assert.Equal(value, uintResult);
+
+            Assert.Equal(value, jsonNumber.GetUInt64());
+            Assert.True(jsonNumber.TryGetUInt64(out ulong ulongResult));
+            Assert.Equal(value, ulongResult);
+
+            Assert.Equal(value, jsonNumber.GetDecimal());
+            Assert.True(jsonNumber.TryGetDecimal(out decimal decimalResult));
+            Assert.Equal(value, decimalResult);
+        }
+
+        [Fact]
+        public static void TestIntegerGetMismatches()
+        {
+            var jsonNumber = new JsonNumber(long.MaxValue);
+
+            // Getting smaller types should fail:
+            Assert.False(jsonNumber.TryGetByte(out byte byteResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetByte());
+
+            Assert.False(jsonNumber.TryGetInt16(out short shortResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetInt16());
+
+            Assert.False(jsonNumber.TryGetInt32(out int intResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetInt32());
+
+            Assert.False(jsonNumber.TryGetSByte(out sbyte sbyteResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetSByte());
+
+            Assert.False(jsonNumber.TryGetUInt16(out ushort ushortResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetUInt16());
+
+            Assert.False(jsonNumber.TryGetUInt32(out uint uintResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetUInt32());
+        }
+
+        [Fact]
+        public static void TestUnsignedGetMismatches()
+        {
+            var jsonNumber = new JsonNumber("-1");
+
+            // Getting unsigned types should fail:
+            Assert.False(jsonNumber.TryGetByte(out byte byteResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetByte());
+
+            Assert.False(jsonNumber.TryGetUInt16(out ushort ushortResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetUInt16());
+
+            Assert.False(jsonNumber.TryGetUInt32(out uint uintResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetUInt32());
+
+            Assert.False(jsonNumber.TryGetUInt64(out ulong ulongResult));
+            Assert.Throws<OverflowException>(() => jsonNumber.GetUInt64());
+        }
+
+        [Fact]
+        public static void TestRationalGetMismatches()
+        {
+            var jsonNumber = new JsonNumber("3.14");
+
+            // Getting integer types should fail:
+            Assert.False(jsonNumber.TryGetByte(out byte byteResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetByte());
+
+            Assert.False(jsonNumber.TryGetInt16(out short shortResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetInt16());
+
+            Assert.False(jsonNumber.TryGetInt32(out int intResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetInt32());
+
+            Assert.False(jsonNumber.TryGetInt64(out long longResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetInt64());
+
+            Assert.False(jsonNumber.TryGetSByte(out sbyte sbyteResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetSByte());
+
+            Assert.False(jsonNumber.TryGetUInt16(out ushort ushortResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetUInt16());
+
+            Assert.False(jsonNumber.TryGetUInt32(out uint uintResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetUInt32());
+
+            Assert.False(jsonNumber.TryGetUInt64(out ulong ulongResult));
+            Assert.Throws<FormatException>(() => jsonNumber.GetUInt64());
+        }
+
+        [Theory]
+        [InlineData("0")]
+        [InlineData("-17")]
+        [InlineData("17")]
+        [InlineData("3.14")]
+        [InlineData("-3.1415")]
+        [InlineData("1234567890")]
+        [InlineData("1e400")]
+        [InlineData("1e+100000002")]
+        [InlineData("184467440737095516150.184467440737095516150")]
+        public static void TestToString(string value)
+        {
+            var jsonNumber = new JsonNumber();
+            jsonNumber.SetFormattedValue(value);
+            Assert.Equal(value, jsonNumber.ToString());
+        }
+
+        [Fact]
+        public static void TestChangingTypes()
+        {
+            var jsonNumber = new JsonNumber(5);
+            Assert.Equal(5, jsonNumber.GetInt32());
+
+            jsonNumber.SetDouble(3.14);
+            Assert.Equal(3.14, jsonNumber.GetDouble());
+
+            jsonNumber.SetByte(17);
+            Assert.Equal(17, jsonNumber.GetByte());
+
+            jsonNumber.SetInt64(long.MaxValue);
+            Assert.Equal(long.MaxValue, jsonNumber.GetInt64());
+
+            jsonNumber.SetUInt16(ushort.MaxValue);
+            Assert.Equal(ushort.MaxValue, jsonNumber.GetUInt16());
+
+            jsonNumber.SetSingle(-1.1f);
+            Assert.Equal(-1.1f, jsonNumber.GetSingle());
+
+            jsonNumber.SetSByte(4);
+            Assert.Equal(4, jsonNumber.GetSByte());
+
+            jsonNumber.SetUInt32(127);
+            Assert.Equal((uint)127, jsonNumber.GetUInt32());
+
+            jsonNumber.SetFormattedValue("1e400");
+            Assert.Equal("1e400", jsonNumber.ToString());
+
+            jsonNumber.SetUInt64(ulong.MaxValue);
+            Assert.Equal(ulong.MaxValue, jsonNumber.GetUInt64());
+
+            jsonNumber.SetDecimal(decimal.MaxValue);
+            Assert.Equal(decimal.MaxValue, jsonNumber.GetDecimal());
+        }
+
+        [Fact]
+        public static void TestImplicitOperators()
+        {
+            byte byteValue = byte.MaxValue;
+            JsonNumber jsonNumber = byteValue;
+            Assert.Equal(byteValue, jsonNumber.GetByte());
+
+            short shortValue = short.MaxValue;
+            jsonNumber = shortValue;
+            Assert.Equal(shortValue, jsonNumber.GetInt16());
+
+            int intValue = int.MaxValue;
+            jsonNumber = intValue;
+            Assert.Equal(intValue, jsonNumber.GetInt32());
+
+            long longValue = long.MaxValue;
+            jsonNumber = longValue;
+            Assert.Equal(longValue, jsonNumber.GetInt64());
+
+            float floatValue = float.MaxValue;
+            jsonNumber = floatValue;
+            Assert.Equal(floatValue, jsonNumber.GetSingle());
+
+            double doubleValue = double.MaxValue;
+            jsonNumber = doubleValue;
+            Assert.Equal(doubleValue, jsonNumber.GetDouble());
+
+            sbyte sbyteValue = sbyte.MaxValue;
+            jsonNumber = sbyteValue;
+            Assert.Equal(sbyteValue, jsonNumber.GetSByte());
+
+            ushort ushortValue = ushort.MaxValue;
+            jsonNumber = ushortValue;
+            Assert.Equal(ushortValue, jsonNumber.GetUInt16());
+
+            uint uintValue = uint.MaxValue;
+            jsonNumber = uintValue;
+            Assert.Equal(uintValue, jsonNumber.GetUInt32());
+
+            ulong ulongValue = ulong.MaxValue;
+            jsonNumber = ulongValue;
+            Assert.Equal(ulongValue, jsonNumber.GetUInt64());
+
+            decimal decimalValue = decimal.MaxValue;
+            jsonNumber = decimalValue;
+            Assert.Equal(decimalValue, jsonNumber.GetDecimal());
+        }
+    }
+}
diff --git a/src/System.Text.Json/tests/WritableJsonApiTests.TestAccessingNestedMembers.cs b/src/System.Text.Json/tests/WritableJsonApiTests.TestAccessingNestedMembers.cs
index cf5b586c7f52..7f3c19d05520 100644
--- a/src/System.Text.Json/tests/WritableJsonApiTests.TestAccessingNestedMembers.cs
+++ b/src/System.Text.Json/tests/WritableJsonApiTests.TestAccessingNestedMembers.cs
@@ -6,9 +6,7 @@
 
 namespace System.Text.Json
 {
-#pragma warning disable xUnit1000
-    internal static partial class WritableJsonApiTests
-#pragma warning enable xUnit1000
+    public static partial class WritableJsonApiTests
     {
         /// <summary>
         /// Accesing nested Json object - casting with as operator
@@ -139,8 +137,8 @@ public static void TestAccesingNestedJsonArrayGetPropertyMethod()
             ((JsonString)issues.GetJsonArrayProperty("features")[1]).Value = "feature 56134";
 
             Assert.True(((JsonArray)issues["bugs"]).Contains("bug 12356"));
-            Assert.Equal((JsonString)((JsonArray)issues["features"])[0], "feature 1569");
-            Assert.Equal((JsonString)((JsonArray)issues["features"])[1], "feature 56134");
+            Assert.Equal("feature 1569", (JsonString)((JsonArray)issues["features"])[0]);
+            Assert.Equal("feature 56134", (JsonString)((JsonArray)issues["features"])[1]);
         }
     }
 }
diff --git a/src/System.Text.Json/tests/WritableJsonApiTests.TestData.cs b/src/System.Text.Json/tests/WritableJsonApiTests.TestData.cs
index e53f85379232..be61a4821844 100644
--- a/src/System.Text.Json/tests/WritableJsonApiTests.TestData.cs
+++ b/src/System.Text.Json/tests/WritableJsonApiTests.TestData.cs
@@ -6,9 +6,7 @@
 
 namespace System.Text.Json
 {
-#pragma warning disable xUnit1000
-    internal static partial class WritableJsonApiTests
-#pragma warning enable xUnit1000
+    public static partial class WritableJsonApiTests
     {
         /// <summary>
         /// Helper class simulating external library
diff --git a/src/System.Text.Json/tests/WritableJsonApiTests.TestModifying.cs b/src/System.Text.Json/tests/WritableJsonApiTests.TestModifying.cs
index e4885b5074b4..6ef4d2659d6c 100644
--- a/src/System.Text.Json/tests/WritableJsonApiTests.TestModifying.cs
+++ b/src/System.Text.Json/tests/WritableJsonApiTests.TestModifying.cs
@@ -7,9 +7,7 @@
 
 namespace System.Text.Json
 {
-#pragma warning disable xUnit1000
-    internal static partial class WritableJsonApiTests
-#pragma warning enable xUnit1000
+    public static partial class WritableJsonApiTests
     {
         /// <summary>
         /// Replacing Json object's primnary types
@@ -28,20 +26,20 @@ public static void TestReplacingsonObjectPrimaryTypes()
             person1["name"] = new JsonString("Bob");
 
             Assert.IsType<JsonString>(person1["name"]);
-            Assert.Equal(person1["name"] as JsonString, "Bob");
+            Assert.Equal("Bob", person1["name"] as JsonString);
 
             // Assign by using an implicit operator on primary Json type
             JsonNumber newAge = 55;
             person1["age"] = newAge;
 
             Assert.IsType<JsonNumber>(person1["age"]);
-            Assert.Equal(person1["age"] as JsonNumber, 55);
+            Assert.Equal(55, person1["age"] as JsonNumber);
 
             // Assign by explicit cast from Json primary type
             person1["is_married"] = (JsonBoolean)false;
 
             Assert.IsType<JsonBoolean>(person1["is_married"]);
-            Assert.Equal(person1["is_married"] as JsonBoolean, false);
+            Assert.Equal(false, person1["is_married"] as JsonBoolean);
 
             // Not possible scenario (wold require implicit cast operators in JsonNode):
             // person["name"] = "Bob";
@@ -57,7 +55,7 @@ public static void TestReplacingsonObjectPrimaryTypes()
             person1["age"] = person2["age"];
 
             Assert.IsType<JsonNumber>(person1["age"]);
-            Assert.Equal(person1["age"] as JsonNumber, 33);
+            Assert.Equal(33, person1["age"] as JsonNumber);
 
             // Copy property of different typoe
             person1["name"] = person2["name"];
@@ -83,8 +81,8 @@ public static void TestModifyingJsonObjectPrimaryTypes()
             Assert.True(isEnabled.Value);
 
             JsonNumber veryBigConstant = new JsonNumber();
-            veryBigConstant.SetString("1e1000");
-            string bigNumber = veryBigConstant.GetString();
+            veryBigConstant.SetFormattedValue("1e1000");
+            string bigNumber = veryBigConstant.ToString();
 
             Assert.Equal("1e1000", bigNumber);
 
diff --git a/src/System.Text.Json/tests/WritableJsonApiTests.TestTransformations.cs b/src/System.Text.Json/tests/WritableJsonApiTests.TestTransformations.cs
index 0b6a5d96ecbc..1707757dcd42 100644
--- a/src/System.Text.Json/tests/WritableJsonApiTests.TestTransformations.cs
+++ b/src/System.Text.Json/tests/WritableJsonApiTests.TestTransformations.cs
@@ -8,9 +8,7 @@
 
 namespace System.Text.Json
 {
-#pragma warning disable xUnit1000
-    internal static partial class WritableJsonApiTests
-#pragma warning enable xUnit1000
+    public static partial class WritableJsonApiTests
     {
         /// <summary>
         /// Transforming JsoneNode to JsonElement
diff --git a/src/System.Text.Json/tests/WritableJsonApiTests.cs b/src/System.Text.Json/tests/WritableJsonApiTests.cs
index e45bff09e714..18856a103cb6 100644
--- a/src/System.Text.Json/tests/WritableJsonApiTests.cs
+++ b/src/System.Text.Json/tests/WritableJsonApiTests.cs
@@ -8,9 +8,7 @@
 
 namespace System.Text.Json
 {
-#pragma warning disable xUnit1000
-    internal static partial class WritableJsonApiTests
-#pragma warning enable xUnit1000
+    public static partial class WritableJsonApiTests
     {
         /// <summary>
         /// Creating simple Json object
@@ -36,7 +34,7 @@ public static void TestCreatingJsonObject()
 
             Assert.IsType<JsonBoolean>(developer["is developer"]);
             var isDeveloperCasted = developer["is developer"] as JsonBoolean;
-            Assert.Equal(true, isDeveloperCasted.Value);
+            Assert.True(isDeveloperCasted.Value);
 
             Assert.Null(developer["null property"]);
         }
@@ -64,7 +62,7 @@ public static void TestCreatingJsonObjectNewMethods()
 
             Assert.IsType<JsonBoolean>(developer["is developer"]);
             var isDeveloperCasted = developer["is developer"] as JsonBoolean;
-            Assert.Equal(true, isDeveloperCasted.Value);
+            Assert.True(isDeveloperCasted.Value);
         }
 
         /// <summary>
@@ -83,7 +81,7 @@ public static void TestNumerics()
 
             Assert.IsType<JsonNumber>(circle["radius"]);
             var radius = circle["radius"] as JsonNumber;
-            Assert.Equal(radius, 1);
+            Assert.Equal(1, radius);
 
             Assert.IsType<JsonNumber>(circle["length"]);
             var length = circle["length"] as JsonNumber;