Enhance serialization handling for non-serialized fields

ConsoleApp/Program.cs

@@ -17,13 +17,13 @@
 var reflector = new Reflector();
 var methodInfo = typeof(Sample).GetMethod(nameof(Sample.Command));
 
-var argumentsSchema = reflector.GetArgumentsSchema(methodInfo);
-var outputSchema = reflector.GetReturnSchema(methodInfo);
+var argumentsSchema = reflector.GetArgumentsSchema(methodInfo!);
+var outputSchema = reflector.GetReturnSchema(methodInfo!);
 
 Console.WriteLine("Arguments Schema:");
 Console.WriteLine(argumentsSchema.ToJsonString(new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));
 Console.WriteLine("Output Schema:");
-Console.WriteLine(outputSchema.ToJsonString(new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));
+Console.WriteLine(outputSchema?.ToJsonString(new System.Text.Json.JsonSerializerOptions { WriteIndented = true }));
 
 var schemaJson = reflector.GetSchema<GameState<PlayerProfile>>();
 
@@ -44,8 +44,8 @@ public class Data
 {
     public int? optionalInt;
     [Description("THIS IS THE DEMO DESCRIPTION.")]
-    public string address;
-    public List<Data> list; // recursive
+    public string address = null!;
+    public List<Data> list = null!; // recursive
 }
 
 public struct Result
@@ -74,15 +74,15 @@ public struct GeoPoint
 public class PlayerProfile
 {
     public Guid Id { get; set; }
-    public string Username { get; set; }
-    public string[] Badges { get; set; } // Array
-    public Dictionary<string, int> Stats { get; set; } // Dictionary
+    public string Username { get; set; } = null!;
+    public string[] Badges { get; set; } = null!; // Array
+    public Dictionary<string, int> Stats { get; set; } = null!; // Dictionary
 }
 
 // A generic wrapper (common in Game State or API responses)
 public class GameState<T>
 {
     public long Timestamp { get; set; }
-    public T Player { get; set; }
-    public List<GeoPoint> Checkpoints { get; set; } // List of Structs
+    public T Player { get; set; } = default!;
+    public List<GeoPoint> Checkpoints { get; set; } = null!; // List of Structs
 }

ReflectorNet.Tests/src/JsonConverterTests/BasicTypesConverterTests.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Text.Json;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace com.IvanMurzak.ReflectorNet.Tests.JsonConverterTests
+{
+    /// <summary>
+    /// Tests for Bool and Char JSON converters
+    /// </summary>
+    public class BasicTypesConverterTests : BaseTest
+    {
+        private readonly Reflector _reflector;
+
+        public BasicTypesConverterTests(ITestOutputHelper output) : base(output)
+        {
+            _reflector = new Reflector();
+        }
+
+        #region BoolJsonConverter Tests
+
+        [Fact]
+        public void Bool_Serialize_True()
+        {
+            var value = true;
+            var json = _reflector.JsonSerializer.Serialize(value);
+            Assert.Equal("true", json);
+        }
+
+        [Fact]
+        public void Bool_Serialize_False()
+        {
+            var value = false;
+            var json = _reflector.JsonSerializer.Serialize(value);
+            Assert.Equal("false", json);
+        }
+
+        [Fact]
+        public void Bool_Deserialize_True()
+        {
+            var json = "true";
+            var result = _reflector.JsonSerializer.Deserialize<bool>(json);
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void Bool_Deserialize_False()
+        {
+            var json = "false";
+            var result = _reflector.JsonSerializer.Deserialize<bool>(json);
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void Bool_Deserialize_FromString()
+        {
+            var json = "\"true\"";
+            var result = _reflector.JsonSerializer.Deserialize<bool>(json);
+            Assert.True(result);
+        }
+
+        #endregion
+
+        #region CharJsonConverter Tests
+
+        [Fact]
+        public void Char_Serialize_Value()
+        {
+            var value = 'A';
+            var json = _reflector.JsonSerializer.Serialize(value);
+            Assert.Equal("\"A\"", json);
+        }
+
+        [Fact]
+        public void Char_Deserialize_Value()
+        {
+            var json = "\"B\"";
+            var result = _reflector.JsonSerializer.Deserialize<char>(json);
+            Assert.Equal('B', result);
+        }
+
+        [Fact]
+        public void Char_Deserialize_FromNumber()
+        {
+            var json = "65";
+            var result = _reflector.JsonSerializer.Deserialize<char>(json);
+            Assert.Equal('A', result);
+        }
+
+        #endregion
+    }
+}

ReflectorNet.Tests/src/JsonConverterTests/BigIntegerConverterTests.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Numerics;
+using System.Text.Json;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace com.IvanMurzak.ReflectorNet.Tests.JsonConverterTests
+{
+    /// <summary>
+    /// Tests for BigInteger JSON converter
+    /// </summary>
+    public class BigIntegerConverterTests : BaseTest
+    {
+        private readonly Reflector _reflector;
+
+        public BigIntegerConverterTests(ITestOutputHelper output) : base(output)
+        {
+            _reflector = new Reflector();
+        }
+
+        #region BigIntegerJsonConverter Tests
+
+        [Fact]
+        public void BigInteger_Serialize_Value()
+        {
+            var value = BigInteger.Parse("123456789012345678901234567890");
+            var json = _reflector.JsonSerializer.Serialize(value);
+            _output.WriteLine($"BigInteger value: {json}");
+            Assert.Contains("123456789012345678901234567890", json);
+        }
+
+        [Fact]
+        public void BigInteger_Serialize_Zero()
+        {
+            var value = BigInteger.Zero;
+            var json = _reflector.JsonSerializer.Serialize(value);
+            _output.WriteLine($"BigInteger zero: {json}");
+            Assert.Equal("\"0\"", json);
+        }
+
+        [Fact]
+        public void BigInteger_Serialize_Negative()
+        {
+            var value = BigInteger.Parse("-98765432109876543210");
+            var json = _reflector.JsonSerializer.Serialize(value);
+            _output.WriteLine($"BigInteger negative: {json}");
+            Assert.Contains("-98765432109876543210", json);
+        }
+
+        [Fact]
+        public void BigInteger_Deserialize_FromNumber()
+        {
+            var json = "12345678901234567890";
+            var result = _reflector.JsonSerializer.Deserialize<BigInteger>(json);
+            _output.WriteLine($"BigInteger from number: {result}");
+            Assert.Equal(BigInteger.Parse("12345678901234567890"), result);
+        }
+
+        [Fact]
+        public void BigInteger_Deserialize_FromString()
+        {
+            var json = "\"999999999999999999999999999999\"";
+            var result = _reflector.JsonSerializer.Deserialize<BigInteger>(json);
+            _output.WriteLine($"BigInteger from string: {result}");
+            Assert.Equal(BigInteger.Parse("999999999999999999999999999999"), result);
+        }
+
+        [Fact]
+        public void BigInteger_RoundTrip()
+        {
+            var original = BigInteger.Pow(2, 100);
+            var json = _reflector.JsonSerializer.Serialize(original);
+            var deserialized = _reflector.JsonSerializer.Deserialize<BigInteger>(json);
+            _output.WriteLine($"BigInteger roundtrip: {original} -> {json} -> {deserialized}");
+            Assert.Equal(original, deserialized);
+        }
+
+        #endregion
+    }
+}