Misc:

* Enable nullable reference types. * Update target framework to .NET 9. * Other changes to adapt to new version of C#.
2025-08-08 17:46:19 +02:00
parent 94b76a1001
commit 9d965e68ae
9 changed files with 1462 additions and 1468 deletions
--- a/VAR.Json.Tests/JsonParser_Tests.cs
+++ b/VAR.Json.Tests/JsonParser_Tests.cs
@@ -1,406 +1,409 @@
 using System.Collections.Generic;
 using Xunit;

-namespace VAR.Json.Tests
+namespace VAR.Json.Tests;
+
+public class JsonParser_Tests
 {
-    public class JsonParser_Tests
+    #region Parse
+
+    private class SwallowObject
    {
-        #region Parse
+        public string? Text { get; set; }
+        public int Number { get; set; }
+    }

-        private class SwallowObject
-        {
-            public string Text { get; set; }
-            public int Number { get; set; }
-        }
+    [Fact]
+    public void Parse__SwallowObject()
+    {
+        JsonParser parser = new();
+        parser.KnownTypes.Add(typeof(SwallowObject));
+        SwallowObject? result = parser.Parse(@"{""Text"": ""AAAA"", ""Number"": 42}") as SwallowObject;
+        Assert.False(parser.Tainted);
+        Assert.Equal("AAAA", result?.Text);
+        Assert.Equal(42, result?.Number);
+    }

-        [Fact]
-        public void Parse__SwallowObject()
-        {
-            JsonParser parser = new JsonParser();
-            parser.KnownTypes.Add(typeof(SwallowObject));
-            SwallowObject result = parser.Parse(@"{""Text"": ""AAAA"", ""Number"": 42}") as SwallowObject;
-            Assert.False(parser.Tainted);
-            Assert.Equal("AAAA", result?.Text);
-            Assert.Equal(42, result.Number);
-        }
+    private class DeeperObject_L1
+    {
+        public string? Name { get; set; }
+        public SwallowObject? Object { get; set; }
+    }

-        private class DeeperObject_L1
-        {
-            public string Name { get; set; }
-            public SwallowObject Object { get; set; }
-        }
+    [Fact]
+    public void Parse__DeeperObject_L1()
+    {
+        JsonParser parser = new();
+        parser.KnownTypes.Add(typeof(SwallowObject));
+        parser.KnownTypes.Add(typeof(DeeperObject_L1));
+        DeeperObject_L1? result =
+            parser.Parse(@"{""Name"": ""Thing"", ""Object"": {""Text"": ""AAAA"", ""Number"": 42}}") as
+                DeeperObject_L1;
+        Assert.False(parser.Tainted);
+        Assert.Equal("Thing", result?.Name);
+        Assert.Equal("AAAA", result?.Object?.Text);
+        Assert.Equal(42, result?.Object?.Number);
+    }

-        [Fact]
-        public void Parse__DeeperObject_L1()
-        {
-            JsonParser parser = new JsonParser();
-            parser.KnownTypes.Add(typeof(SwallowObject));
-            parser.KnownTypes.Add(typeof(DeeperObject_L1));
-            DeeperObject_L1 result =
-                parser.Parse(@"{""Name"": ""Thing"", ""Object"": {""Text"": ""AAAA"", ""Number"": 42}}") as
-                    DeeperObject_L1;
-            Assert.False(parser.Tainted);
-            Assert.Equal("Thing", result.Name);
-            Assert.Equal("AAAA", result.Object.Text);
-            Assert.Equal(42, result.Object.Number);
-        }
+    private class DeeperObject_L2
+    {
+        public int Count { get; set; }
+        public DeeperObject_L1? Object { get; set; }
+    }

-        private class DeeperObject_L2
-        {
-            public int Count { get; set; }
-            public DeeperObject_L1 Object { get; set; }
-        }
+    [Fact]
+    public void Parse__DeeperObject_L2()
+    {
+        JsonParser parser = new();
+        parser.KnownTypes.Add(typeof(SwallowObject));
+        parser.KnownTypes.Add(typeof(DeeperObject_L1));
+        parser.KnownTypes.Add(typeof(DeeperObject_L2));
+        DeeperObject_L2? result =
+            parser.Parse(
+                    @"{""Count"": 1, ""Object"": {""Name"": ""Thing"", ""Object"": {""Text"": ""AAAA"", ""Number"": 42}}}")
+                as DeeperObject_L2;
+        Assert.False(parser.Tainted);
+        Assert.NotNull(result);
+        Assert.Equal(1, result?.Count);
+        Assert.Equal("Thing", result?.Object?.Name);
+        Assert.Equal("AAAA", result?.Object?.Object?.Text);
+        Assert.Equal(42, result?.Object?.Object?.Number);
+    }

-        [Fact]
-        public void Parse__DeeperObject_L2()
-        {
-            JsonParser parser = new JsonParser();
-            parser.KnownTypes.Add(typeof(SwallowObject));
-            parser.KnownTypes.Add(typeof(DeeperObject_L1));
-            parser.KnownTypes.Add(typeof(DeeperObject_L2));
-            DeeperObject_L2 result =
-                parser.Parse(
-                        @"{""Count"": 1, ""Object"": {""Name"": ""Thing"", ""Object"": {""Text"": ""AAAA"", ""Number"": 42}}}")
-                    as DeeperObject_L2;
-            Assert.False(parser.Tainted);
-            Assert.Equal(1, result.Count);
-            Assert.Equal("Thing", result.Object.Name);
-            Assert.Equal("AAAA", result.Object.Object.Text);
-            Assert.Equal(42, result.Object.Object.Number);
-        }
+    [Fact]
+    public void Parse__SwallowObjectArray()
+    {
+        JsonParser parser = new();
+        parser.KnownTypes.Add(typeof(SwallowObject));
+        List<SwallowObject>? result = parser.Parse(@"[{""Text"": ""AAAA"", ""Number"": 42}]") as List<SwallowObject>;
+        Assert.False(parser.Tainted);
+        Assert.NotNull(result);
+        Assert.Single(result);
+        Assert.Equal("AAAA", result?[0].Text);
+        Assert.Equal(42, result?[0].Number);
+    }

-        [Fact]
-        public void Parse__SwallowObjectArray()
-        {
-            JsonParser parser = new JsonParser();
-            parser.KnownTypes.Add(typeof(SwallowObject));
-            List<SwallowObject> result = parser.Parse(@"[{""Text"": ""AAAA"", ""Number"": 42}]") as List<SwallowObject>;
-            Assert.False(parser.Tainted);
-            Assert.Single(result);
-            Assert.Equal("AAAA", result[0].Text);
-            Assert.Equal(42, result[0].Number);
-        }
+    private class DeeperObjectArray_L1
+    {
+        public int Count { get; set; }
+        public List<SwallowObject>? Array { get; set; }
+    }

-        private class DeeperObjectArray_L1
-        {
-            public int Count { get; set; }
-            public List<SwallowObject> Array { get; set; }
-        }
+    [Fact]
+    public void Parse__DeeperObjectArray_L1()
+    {
+        JsonParser parser = new();
+        parser.KnownTypes.Add(typeof(SwallowObject));
+        parser.KnownTypes.Add(typeof(DeeperObjectArray_L1));
+        DeeperObjectArray_L1? result =
+            parser.Parse(@"{""Count"": 1, ""Array"": [{""Text"": ""AAAA"", ""Number"": 42}]}") as
+                DeeperObjectArray_L1;
+        Assert.False(parser.Tainted);
+        Assert.NotNull(result);
+        Assert.Equal(1, result?.Count);
+        Assert.Equal("AAAA", result?.Array?[0].Text);
+        Assert.Equal(42, result?.Array?[0].Number);
+    }

-        [Fact]
-        public void Parse__DeeperObjectArray_L1()
-        {
-            JsonParser parser = new JsonParser();
-            parser.KnownTypes.Add(typeof(SwallowObject));
-            parser.KnownTypes.Add(typeof(DeeperObjectArray_L1));
-            DeeperObjectArray_L1 result =
-                parser.Parse(@"{""Count"": 1, ""Array"": [{""Text"": ""AAAA"", ""Number"": 42}]}") as
-                    DeeperObjectArray_L1;
-            Assert.False(parser.Tainted);
-            Assert.Equal(1, result.Count);
-            Assert.Equal("AAAA", result.Array[0].Text);
-            Assert.Equal(42, result.Array[0].Number);
-        }
+    private class DeeperObjectArray_L2
+    {
+        public string Name { get; set; } = string.Empty;
+        public List<DeeperObjectArray_L1> Objects { get; set; } = [];
+    }

-        private class DeeperObjectArray_L2
-        {
-            public string Name { get; set; }
-            public List<DeeperObjectArray_L1> Objects { get; set; }
-        }
+    [Fact]
+    public void Parse__DeeperObjectArray_L2()
+    {
+        JsonParser parser = new();
+        parser.KnownTypes.Add(typeof(SwallowObject));
+        parser.KnownTypes.Add(typeof(DeeperObjectArray_L1));
+        parser.KnownTypes.Add(typeof(DeeperObjectArray_L2));
+        DeeperObjectArray_L2? result =
+            parser.Parse(
+                    @"{""Name"": ""Thing"", ""Objects"": [{""Count"": 1, ""Array"": [{""Text"": ""AAAA"", ""Number"": 42}]}]}")
+                as DeeperObjectArray_L2;
+        Assert.False(parser.Tainted);
+        Assert.Equal("Thing", result?.Name);
+        Assert.Equal(1, result?.Objects[0].Count);
+        Assert.Equal("AAAA", result?.Objects[0].Array?[0].Text);
+        Assert.Equal(42, result?.Objects[0].Array?[0].Number);
+    }

-        [Fact]
-        public void Parse__DeeperObjectArray_L2()
-        {
-            JsonParser parser = new JsonParser();
-            parser.KnownTypes.Add(typeof(SwallowObject));
-            parser.KnownTypes.Add(typeof(DeeperObjectArray_L1));
-            parser.KnownTypes.Add(typeof(DeeperObjectArray_L2));
-            DeeperObjectArray_L2 result =
-                parser.Parse(
-                        @"{""Name"": ""Thing"", ""Objects"": [{""Count"": 1, ""Array"": [{""Text"": ""AAAA"", ""Number"": 42}]}]}")
-                    as DeeperObjectArray_L2;
-            Assert.False(parser.Tainted);
-            Assert.Equal("Thing", result.Name);
-            Assert.Equal(1, result.Objects[0].Count);
-            Assert.Equal("AAAA", result.Objects[0].Array[0].Text);
-            Assert.Equal(42, result.Objects[0].Array[0].Number);
-        }
+    #endregion Parse

-        #endregion Parse
+    #region Validity tests

-        #region Validity tests
+    [Fact]
+    public void Parse__Validity_Fail01()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"""A JSON payload should be an object or array, not a string.""");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail01()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"""A JSON payload should be an object or array, not a string.""");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail02()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Unclosed array""");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail02()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Unclosed array""");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail03()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{unquoted_key: ""keys must be quoted""}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail03()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{unquoted_key: ""keys must be quoted""}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail04()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""extra comma"",]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail04()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""extra comma"",]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail05()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""double extra comma"",,]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail05()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""double extra comma"",,]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail06()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[   , ""<-- missing value""]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail06()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[   , ""<-- missing value""]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail07()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Comma after the close""],");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail07()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Comma after the close""],");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail08()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Extra close""]]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail08()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Extra close""]]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail09()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Extra comma"": true,}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail09()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Extra comma"": true,}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail10()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Extra value after close"": true} ""misplaced quoted value""");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail10()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Extra value after close"": true} ""misplaced quoted value""");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail11()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Illegal expression"": 1 + 2}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail11()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Illegal expression"": 1 + 2}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail12()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Illegal invocation"": alert()}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail12()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Illegal invocation"": alert()}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail13()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Numbers cannot have leading zeroes"": 013}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail13()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Numbers cannot have leading zeroes"": 013}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail14()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Numbers cannot be hex"": 0x14}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail14()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Numbers cannot be hex"": 0x14}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail15()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Illegal backslash escape: \x15""]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail15()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Illegal backslash escape: \x15""]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail16()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[\naked]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail16()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[\naked]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail17()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Illegal backslash escape: \017""]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail17()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Illegal backslash escape: \017""]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail18()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[[[[[[[[[[[[[[[[[[[[""Too deep""]]]]]]]]]]]]]]]]]]]]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail18()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[[[[[[[[[[[[[[[[[[[[""Too deep""]]]]]]]]]]]]]]]]]]]]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail19()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Missing colon"" null}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail19()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Missing colon"" null}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail20()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Double colon"":: null}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail20()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Double colon"":: null}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail21()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Comma instead of colon"", null}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail21()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Comma instead of colon"", null}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail22()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Colon instead of comma"": false]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail22()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Colon instead of comma"": false]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail23()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""Bad value"", truth]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail23()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""Bad value"", truth]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail24()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"['single quote']");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail24()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"['single quote']");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail25()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""	tab	character	in	string	""]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail25()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""	tab	character	in	string	""]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail26()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""tab\   character\   in\  string\  ""]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail26()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""tab\   character\   in\  string\  ""]");
-            Assert.True(parser.Tainted);
-        }
-
-        [Fact]
-        public void Parse__Validity_Fail27()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""line
+    [Fact]
+    public void Parse__Validity_Fail27()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""line
 break""]");
-            Assert.True(parser.Tainted);
-        }
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail28()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""line\
+    [Fact]
+    public void Parse__Validity_Fail28()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""line\
 break""]");
-            Assert.True(parser.Tainted);
-        }
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail29()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[0e]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail29()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[0e]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail30()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[0e+]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail30()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[0e+]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail31()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[0e+-1]");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail31()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[0e+-1]");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail32()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{""Comma instead if closing brace"": true,");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail32()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{""Comma instead if closing brace"": true,");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Fail33()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[""mismatch""}");
-            Assert.True(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Fail33()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[""mismatch""}");
+        Assert.True(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Pass01()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[
+    [Fact]
+    public void Parse__Validity_Pass01()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[
    ""JSON Test Pattern pass1"",
    {""object with 1 member"":[""array with 1 element""]},
    {},
@@ -458,31 +461,30 @@ break""]");
 1e-1,
 1e00,2e+00,2e-00
 ,""rosebud""]");
-            Assert.False(parser.Tainted);
-        }
+        Assert.False(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Pass02()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"[[[[[[[[[[[[[[[[[[[""Not too deep""]]]]]]]]]]]]]]]]]]]");
-            Assert.False(parser.Tainted);
-        }
+    [Fact]
+    public void Parse__Validity_Pass02()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"[[[[[[[[[[[[[[[[[[[""Not too deep""]]]]]]]]]]]]]]]]]]]");
+        Assert.False(parser.Tainted);
+    }

-        [Fact]
-        public void Parse__Validity_Pass03()
-        {
-            JsonParser parser = new JsonParser();
-            parser.Parse(@"{
+    [Fact]
+    public void Parse__Validity_Pass03()
+    {
+        JsonParser parser = new();
+        parser.Parse(@"{
    ""JSON Test Pattern pass3"": {
        ""The outermost value"": ""must be an object or array."",
        ""In this test"": ""It is an object.""
    }
 }
 ");
-            Assert.False(parser.Tainted);
-        }
-
-        #endregion Validity tests
+        Assert.False(parser.Tainted);
    }
+
+    #endregion Validity tests
 }
--- a/VAR.Json.Tests/VAR.Json.Tests.csproj
+++ b/VAR.Json.Tests/VAR.Json.Tests.csproj
@@ -1,9 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>

        <IsPackable>false</IsPackable>
+        <Nullable>enable</Nullable>
+        <LangVersion>default</LangVersion>
    </PropertyGroup>

    <ItemGroup>