".HtmlEncode();
+ Assert.Contains("<", result);
+ }
+
+ [Fact]
+ public void HtmlDecode_Decodes_Entities()
+ {
+ var result = "<div>".HtmlDecode();
+ Assert.Equal("
", result);
+ }
+ }
+}
diff --git a/RestSharp.Tests.Coverage/ValidationTests.cs b/RestSharp.Tests.Coverage/ValidationTests.cs
new file mode 100644
index 000000000..24899f1f5
--- /dev/null
+++ b/RestSharp.Tests.Coverage/ValidationTests.cs
@@ -0,0 +1,87 @@
+using System;
+using RestSharp.Validation;
+using Xunit;
+
+namespace RestSharp.Tests
+{
+ public class ValidationTests
+ {
+ [Fact]
+ public void IsBetween_Valid_Does_Not_Throw()
+ {
+ Validate.IsBetween(5, 1, 10);
+ }
+
+ [Fact]
+ public void IsBetween_At_Min_Does_Not_Throw()
+ {
+ Validate.IsBetween(1, 1, 10);
+ }
+
+ [Fact]
+ public void IsBetween_At_Max_Does_Not_Throw()
+ {
+ Validate.IsBetween(10, 1, 10);
+ }
+
+ [Fact]
+ public void IsBetween_Below_Min_Throws()
+ {
+ Assert.Throws
(() => Validate.IsBetween(0, 1, 10));
+ }
+
+ [Fact]
+ public void IsBetween_Above_Max_Throws()
+ {
+ Assert.Throws(() => Validate.IsBetween(11, 1, 10));
+ }
+
+ [Fact]
+ public void IsValidLength_Valid_Does_Not_Throw()
+ {
+ Validate.IsValidLength("hello", 10);
+ }
+
+ [Fact]
+ public void IsValidLength_Exact_Max_Does_Not_Throw()
+ {
+ Validate.IsValidLength("hello", 5);
+ }
+
+ [Fact]
+ public void IsValidLength_Null_Does_Not_Throw()
+ {
+ Validate.IsValidLength(null, 5);
+ }
+
+ [Fact]
+ public void IsValidLength_Too_Long_Throws()
+ {
+ Assert.Throws(() => Validate.IsValidLength("hello world", 5));
+ }
+
+ [Fact]
+ public void IsValidLength_Empty_String_Does_Not_Throw()
+ {
+ Validate.IsValidLength("", 0);
+ }
+
+ [Fact]
+ public void Require_Argument_Valid_Does_Not_Throw()
+ {
+ Require.Argument("param", "value");
+ }
+
+ [Fact]
+ public void Require_Argument_Null_Throws()
+ {
+ Assert.Throws(() => Require.Argument("param", null));
+ }
+
+ [Fact]
+ public void Require_Argument_Object_Does_Not_Throw()
+ {
+ Require.Argument("param", new object());
+ }
+ }
+}
diff --git a/RestSharp.Tests.Coverage/WebPairCollectionTests.cs b/RestSharp.Tests.Coverage/WebPairCollectionTests.cs
new file mode 100644
index 000000000..de797c3f9
--- /dev/null
+++ b/RestSharp.Tests.Coverage/WebPairCollectionTests.cs
@@ -0,0 +1,245 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using RestSharp.Authenticators.OAuth;
+using Xunit;
+
+namespace RestSharp.Tests
+{
+ public class WebPairCollectionTests
+ {
+ [Fact]
+ public void Default_Constructor_Empty()
+ {
+ var coll = new WebPairCollection();
+ Assert.Equal(0, coll.Count);
+ }
+
+ [Fact]
+ public void Constructor_With_Capacity()
+ {
+ var coll = new WebPairCollection(10);
+ Assert.Equal(0, coll.Count);
+ }
+
+ [Fact]
+ public void Constructor_With_Pairs()
+ {
+ var pairs = new List { new WebPair("a", "1"), new WebPair("b", "2") };
+ var coll = new WebPairCollection(pairs);
+ Assert.Equal(2, coll.Count);
+ }
+
+ [Fact]
+ public void Constructor_With_Dictionary()
+ {
+ var dict = new Dictionary { { "a", "1" }, { "b", "2" } };
+ var coll = new WebPairCollection(dict);
+ Assert.Equal(2, coll.Count);
+ }
+
+ [Fact]
+ public void Constructor_With_NameValueCollection()
+ {
+ var nvc = new NameValueCollection { { "a", "1" }, { "b", "2" } };
+ var coll = new WebPairCollection(nvc);
+ Assert.Equal(2, coll.Count);
+ }
+
+ [Fact]
+ public void Indexer_By_Name()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("test", "value");
+ Assert.Equal("value", coll["test"].Value);
+ }
+
+ [Fact]
+ public void Names_Property()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ Assert.Contains("a", coll.Names);
+ Assert.Contains("b", coll.Names);
+ }
+
+ [Fact]
+ public void Values_Property()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ Assert.Contains("1", coll.Values);
+ Assert.Contains("2", coll.Values);
+ }
+
+ [Fact]
+ public void AddRange_NameValueCollection()
+ {
+ var coll = new WebPairCollection();
+ var nvc = new NameValueCollection { { "a", "1" } };
+ coll.AddRange(nvc);
+ Assert.Single(coll);
+ }
+
+ [Fact]
+ public void AddRange_WebPairCollection()
+ {
+ var coll = new WebPairCollection();
+ var other = new WebPairCollection();
+ other.Add("a", "1");
+ coll.AddRange(other);
+ Assert.Single(coll);
+ }
+
+ [Fact]
+ public void AddRange_IEnumerable()
+ {
+ var coll = new WebPairCollection();
+ var list = new List { new WebPair("a", "1") };
+ coll.AddRange(list);
+ Assert.Single(coll);
+ }
+
+ [Fact]
+ public void RemoveAll()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ var toRemove = coll.Where(p => p.Name == "a").ToList();
+ var result = coll.RemoveAll(toRemove);
+ Assert.True(result);
+ Assert.Single(coll);
+ }
+
+ [Fact]
+ public void RemoveAll_Empty_Returns_False()
+ {
+ var coll = new WebPairCollection();
+ var result = coll.RemoveAll(new List());
+ Assert.False(result);
+ }
+
+ [Fact]
+ public void Clear()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Clear();
+ Assert.Equal(0, coll.Count);
+ }
+
+ [Fact]
+ public void Contains()
+ {
+ var coll = new WebPairCollection();
+ var pair = new WebPair("a", "1");
+ coll.Add(pair);
+ Assert.True(coll.Contains(pair));
+ }
+
+ [Fact]
+ public void CopyTo()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ var array = new WebPair[2];
+ coll.CopyTo(array, 0);
+ Assert.Equal("a", array[0].Name);
+ }
+
+ [Fact]
+ public void Remove()
+ {
+ var coll = new WebPairCollection();
+ var pair = new WebPair("a", "1");
+ coll.Add(pair);
+ Assert.True(coll.Remove(pair));
+ Assert.Equal(0, coll.Count);
+ }
+
+ [Fact]
+ public void IsReadOnly()
+ {
+ var coll = new WebPairCollection();
+ Assert.False(coll.IsReadOnly);
+ }
+
+ [Fact]
+ public void IndexOf()
+ {
+ var coll = new WebPairCollection();
+ var pair = new WebPair("a", "1");
+ coll.Add(pair);
+ Assert.Equal(0, coll.IndexOf(pair));
+ }
+
+ [Fact]
+ public void Insert()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("b", "2");
+ coll.Insert(0, new WebPair("a", "1"));
+ Assert.Equal("a", coll[0].Name);
+ }
+
+ [Fact]
+ public void RemoveAt()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ coll.RemoveAt(0);
+ Assert.Single(coll);
+ Assert.Equal("b", coll[0].Name);
+ }
+
+ [Fact]
+ public void IntIndexer_Set()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll[0] = new WebPair("b", "2");
+ Assert.Equal("b", coll[0].Name);
+ }
+
+ [Fact]
+ public void Sort()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("c", "3");
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ coll.Sort((l, r) => string.Compare(l.Name, r.Name, StringComparison.Ordinal));
+ Assert.Equal("a", coll[0].Name);
+ Assert.Equal("b", coll[1].Name);
+ Assert.Equal("c", coll[2].Name);
+ }
+
+ [Fact]
+ public void GetEnumerator_Enumerates()
+ {
+ var coll = new WebPairCollection();
+ coll.Add("a", "1");
+ coll.Add("b", "2");
+ var count = 0;
+ foreach (var item in coll)
+ {
+ count++;
+ }
+ Assert.Equal(2, count);
+ }
+
+ [Fact]
+ public void Add_WebPair_Object()
+ {
+ var coll = new WebPairCollection();
+ coll.Add(new WebPair("key", "val"));
+ Assert.Equal("key", coll[0].Name);
+ }
+ }
+}
diff --git a/RestSharp.Tests.Coverage/XmlAttributeDeserializerTests.cs b/RestSharp.Tests.Coverage/XmlAttributeDeserializerTests.cs
new file mode 100644
index 000000000..7cc48035d
--- /dev/null
+++ b/RestSharp.Tests.Coverage/XmlAttributeDeserializerTests.cs
@@ -0,0 +1,284 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using RestSharp.Deserializers;
+using Xunit;
+
+namespace RestSharp.Tests
+{
+ public class XmlAttributeDeserializerTests
+ {
+ [Fact]
+ public void Default_Culture_Is_Invariant()
+ {
+ var d = new XmlAttributeDeserializer();
+ Assert.Equal(CultureInfo.InvariantCulture, d.Culture);
+ }
+
+ [Fact]
+ public void Deserialize_Simple_Element()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "Hello42";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("Hello", obj.Name);
+ Assert.Equal(42, obj.Value);
+ }
+
+ [Fact]
+ public void Deserialize_Null_Content_Returns_Default()
+ {
+ var d = new XmlAttributeDeserializer();
+ var response = new RestResponse();
+ // Set Content field to null via RawBytes=null and reflection,
+ // since Content derives from RawBytes (returns "" for null bytes)
+ // The deserializer checks response.Content == null
+ var prop = typeof(RestResponse).GetProperty("Content");
+ // We need to create a response where Content is actually null
+ // The code checks `response.Content == null` so we need to construct carefully
+ // RestResponse.Content returns "" when RawBytes is null, so the null check
+ // in XmlAttributeDeserializer won't hit via normal RestResponse.
+ // Just verify it doesn't crash on valid minimal XML
+ response = new RestResponse { Content = "" };
+ var obj = d.Deserialize(response);
+ Assert.NotNull(obj);
+ }
+
+ [Fact]
+ public void Deserialize_With_RootElement()
+ {
+ var d = new XmlAttributeDeserializer { RootElement = "Data" };
+ var xml = "Test1";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("Test", obj.Name);
+ }
+
+ [Fact]
+ public void Deserialize_Attributes()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "AttrName99";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("AttrName", obj.Name);
+ Assert.Equal(99, obj.Value);
+ }
+
+ [Fact]
+ public void Deserialize_Boolean_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "true";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.True(obj.Active);
+ }
+
+ [Fact]
+ public void Deserialize_DateTime_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "2024-06-15T12:00:00";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2024, obj.Created.Year);
+ }
+
+ [Fact]
+ public void Deserialize_Decimal_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "19.99";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(19.99m, obj.Amount);
+ }
+
+ [Fact]
+ public void Deserialize_Long_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "9999999999";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(9999999999, obj.BigNum);
+ }
+
+ [Fact]
+ public void Deserialize_Double_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "3.14";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(3.14, obj.Ratio, 2);
+ }
+
+ [Fact]
+ public void Deserialize_Nullable_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "42";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(42, obj.NullableVal);
+ }
+
+ [Fact]
+ public void Deserialize_Nullable_Missing_Returns_Null()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Null(obj.NullableVal);
+ }
+
+ [Fact]
+ public void Deserialize_Guid_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var guid = Guid.NewGuid();
+ var xml = $"{guid}";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(guid, obj.Id);
+ }
+
+ [Fact]
+ public void Deserialize_Uri_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "http://example.com/test";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("http://example.com/test", obj.Link.ToString());
+ }
+
+ [Fact]
+ public void Deserialize_Enum_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "Completed";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(ResponseStatus.Completed, obj.Status);
+ }
+
+ [Fact]
+ public void Deserialize_List_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "A1B2";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2, obj.Items.Count);
+ }
+
+ [Fact]
+ public void Deserialize_String_Property_From_Attribute()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "FromElement7";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("FromElement", obj.Name);
+ Assert.Equal(7, obj.Value);
+ }
+
+ [Fact]
+ public void Deserialize_With_Namespace()
+ {
+ var d = new XmlAttributeDeserializer { Namespace = "http://example.com/ns" };
+ var xml = "NSTest5";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("NSTest", obj.Name);
+ }
+
+ [Fact]
+ public void Deserialize_With_DateFormat()
+ {
+ var d = new XmlAttributeDeserializer { DateFormat = "yyyy-MM-dd" };
+ var xml = "2024-06-15";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2024, obj.Created.Year);
+ Assert.Equal(6, obj.Created.Month);
+ }
+
+ [Fact]
+ public void Deserialize_Float_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "1.5";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(1.5f, obj.Score, 1);
+ }
+
+ [Fact]
+ public void Deserialize_Short_Property()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "123";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(123, obj.SmallNum);
+ }
+
+ [Fact]
+ public void Deserialize_With_DeserializeAs_Attribute()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "Custom";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal("Custom", obj.CustomProp);
+ }
+
+ [Fact]
+ public void Deserialize_Int_From_Attribute_Xml()
+ {
+ var d = new XmlAttributeDeserializer();
+ var xml = "Test100";
+ var response = new RestResponse { Content = xml };
+ var obj = d.Deserialize(response);
+ Assert.Equal(100, obj.Value);
+ }
+
+ public class TestItem
+ {
+ public string Name { get; set; }
+ public int Value { get; set; }
+ }
+
+ public class AttrItem
+ {
+ public string Name { get; set; }
+ public int Value { get; set; }
+ }
+
+ public class BoolItem { public bool Active { get; set; } }
+ public class DateItem { public DateTime Created { get; set; } }
+ public class DecItem { public decimal Amount { get; set; } }
+ public class LongItem { public long BigNum { get; set; } }
+ public class DoubleItem { public double Ratio { get; set; } }
+ public class NullableItem { public int? NullableVal { get; set; } }
+ public class GuidItem { public Guid Id { get; set; } }
+ public class UriItem { public Uri Link { get; set; } }
+ public class EnumItem { public ResponseStatus Status { get; set; } }
+ public class ListItem { public List Items { get; set; } }
+ public class NestedItem { public TestItem Child { get; set; } }
+ public class FloatItem { public float Score { get; set; } }
+ public class ShortItem { public short SmallNum { get; set; } }
+
+ public class DeserializeAsItem
+ {
+ [DeserializeAs(Name = "custom_name")]
+ public string CustomProp { get; set; }
+ }
+ }
+}
diff --git a/RestSharp.Tests.Coverage/XmlSerializerEdgeTests.cs b/RestSharp.Tests.Coverage/XmlSerializerEdgeTests.cs
new file mode 100644
index 000000000..259838565
--- /dev/null
+++ b/RestSharp.Tests.Coverage/XmlSerializerEdgeTests.cs
@@ -0,0 +1,359 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using RestSharp.Deserializers;
+using RestSharp.Serializers;
+using Xunit;
+
+namespace RestSharp.Tests
+{
+ public class XmlSerializerEdgeTests
+ {
+ [Fact]
+ public void XmlSerializer_Default_ContentType()
+ {
+ var serializer = new XmlSerializer();
+ Assert.Equal("text/xml", serializer.ContentType);
+ }
+
+ [Fact]
+ public void XmlSerializer_Namespace_Property()
+ {
+ var serializer = new XmlSerializer();
+ serializer.Namespace = "http://example.com/ns";
+ Assert.Equal("http://example.com/ns", serializer.Namespace);
+ }
+
+ [Fact]
+ public void XmlSerializer_DateFormat_Property()
+ {
+ var serializer = new XmlSerializer();
+ serializer.DateFormat = "yyyy-MM-dd";
+ Assert.Equal("yyyy-MM-dd", serializer.DateFormat);
+ }
+
+ [Fact]
+ public void XmlSerializer_RootElement_Property()
+ {
+ var serializer = new XmlSerializer();
+ serializer.RootElement = "Root";
+ Assert.Equal("Root", serializer.RootElement);
+ }
+
+ [Fact]
+ public void XmlSerializer_Serialize_Simple_Object()
+ {
+ var serializer = new XmlSerializer();
+ var result = serializer.Serialize(new SimpleObj { Name = "Test", Value = 42 });
+ Assert.Contains("Test", result);
+ Assert.Contains("42", result);
+ }
+
+ [Fact]
+ public void XmlDeserializer_Default_Culture()
+ {
+ var d = new XmlDeserializer();
+ Assert.Equal(CultureInfo.InvariantCulture, d.Culture);
+ }
+
+ [Fact]
+ public void XmlDeserializer_RootElement_Property()
+ {
+ var d = new XmlDeserializer();
+ d.RootElement = "data";
+ Assert.Equal("data", d.RootElement);
+ }
+
+ [Fact]
+ public void XmlDeserializer_Namespace_Property()
+ {
+ var d = new XmlDeserializer();
+ d.Namespace = "http://example.com/ns";
+ Assert.Equal("http://example.com/ns", d.Namespace);
+ }
+
+ [Fact]
+ public void XmlDeserializer_DateFormat_Property()
+ {
+ var d = new XmlDeserializer();
+ d.DateFormat = "yyyy-MM-dd";
+ Assert.Equal("yyyy-MM-dd", d.DateFormat);
+ }
+
+ [Fact]
+ public void XmlDeserializer_Deserialize_Simple()
+ {
+ var d = new XmlDeserializer();
+ var response = new RestResponse { Content = "Hello99" };
+ var obj = d.Deserialize(response);
+ Assert.Equal("Hello", obj.Name);
+ Assert.Equal(99, obj.Value);
+ }
+
+ [Fact]
+ public void XmlDeserializer_Deserialize_With_RootElement()
+ {
+ var d = new XmlDeserializer { RootElement = "Data" };
+ var response = new RestResponse { Content = "Test1" };
+ var obj = d.Deserialize(response);
+ Assert.Equal("Test", obj.Name);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Default_Culture()
+ {
+ var d = new JsonDeserializer();
+ Assert.Equal(CultureInfo.InvariantCulture, d.Culture);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_With_RootElement()
+ {
+ var d = new JsonDeserializer { RootElement = "data" };
+ var response = new RestResponse { Content = "{\"data\": {\"Name\": \"Test\", \"Value\": 42}}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal("Test", obj.Name);
+ Assert.Equal(42, obj.Value);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_List()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "[{\"Name\": \"A\", \"Value\": 1}, {\"Name\": \"B\", \"Value\": 2}]" };
+ var list = d.Deserialize>(response);
+ Assert.Equal(2, list.Count);
+ Assert.Equal("A", list[0].Name);
+ Assert.Equal("B", list[1].Name);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_List_With_RootElement()
+ {
+ var d = new JsonDeserializer { RootElement = "items" };
+ var response = new RestResponse { Content = "{\"items\": [{\"Name\": \"A\"}, {\"Name\": \"B\"}]}" };
+ var list = d.Deserialize>(response);
+ Assert.Equal(2, list.Count);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Dictionary()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"key1\": \"val1\", \"key2\": \"val2\"}" };
+ var dict = d.Deserialize>(response);
+ Assert.Equal(2, dict.Count);
+ Assert.Equal("val1", dict["key1"]);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_With_DateFormat()
+ {
+ var d = new JsonDeserializer { DateFormat = "yyyy-MM-dd" };
+ var response = new RestResponse { Content = "{\"Date\": \"2024-06-15\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2024, obj.Date.Year);
+ Assert.Equal(6, obj.Date.Month);
+ Assert.Equal(15, obj.Date.Day);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Nullable_Int()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"NullableValue\": 42}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(42, obj.NullableValue);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Null_Nullable_Int()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"NullableValue\": null}" };
+ var obj = d.Deserialize(response);
+ Assert.Null(obj.NullableValue);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Enum()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Status\": \"Completed\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(ResponseStatus.Completed, obj.Status);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Guid()
+ {
+ var d = new JsonDeserializer();
+ var guid = Guid.NewGuid();
+ var response = new RestResponse { Content = "{\"Id\": \"" + guid + "\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(guid, obj.Id);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_EmptyGuid()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Id\": \"\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(Guid.Empty, obj.Id);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Uri()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Link\": \"http://example.com/test\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal("http://example.com/test", obj.Link.ToString());
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Decimal()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Amount\": \"19.99\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(19.99m, obj.Amount);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Nested_Object()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Inner\": {\"Name\": \"nested\", \"Value\": 1}}" };
+ var obj = d.Deserialize(response);
+ Assert.NotNull(obj.Inner);
+ Assert.Equal("nested", obj.Inner.Name);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Nested_List()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Items\": [{\"Name\": \"A\"}, {\"Name\": \"B\"}]}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2, obj.Items.Count);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Nested_Dictionary()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Data\": {\"key1\": \"val1\", \"key2\": \"val2\"}}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2, obj.Data.Count);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Boolean_Property()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Active\": true}" };
+ var obj = d.Deserialize(response);
+ Assert.True(obj.Active);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Long_Property()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"BigNumber\": 9999999999}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(9999999999L, obj.BigNumber);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_Double_Property()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Ratio\": 3.14}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(3.14, obj.Ratio, 2);
+ }
+
+ [Fact]
+ public void JsonDeserializer_Deserialize_DateTimeOffset()
+ {
+ var d = new JsonDeserializer();
+ var response = new RestResponse { Content = "{\"Stamp\": \"2024-06-15T12:00:00Z\"}" };
+ var obj = d.Deserialize(response);
+ Assert.Equal(2024, obj.Stamp.Year);
+ }
+
+ public class SimpleObj
+ {
+ public string Name { get; set; }
+ public int Value { get; set; }
+ }
+
+ public class ObjWithDate
+ {
+ public DateTime Date { get; set; }
+ }
+
+ public class ObjWithNullable
+ {
+ public int? NullableValue { get; set; }
+ }
+
+ public class ObjWithEnum
+ {
+ public ResponseStatus Status { get; set; }
+ }
+
+ public class ObjWithGuid
+ {
+ public Guid Id { get; set; }
+ }
+
+ public class ObjWithUri
+ {
+ public Uri Link { get; set; }
+ }
+
+ public class ObjWithDecimal
+ {
+ public decimal Amount { get; set; }
+ }
+
+ public class ObjWithNested
+ {
+ public SimpleObj Inner { get; set; }
+ }
+
+ public class ObjWithList
+ {
+ public List Items { get; set; }
+ }
+
+ public class ObjWithDict
+ {
+ public Dictionary Data { get; set; }
+ }
+
+ public class ObjWithBool
+ {
+ public bool Active { get; set; }
+ }
+
+ public class ObjWithLong
+ {
+ public long BigNumber { get; set; }
+ }
+
+ public class ObjWithDouble
+ {
+ public double Ratio { get; set; }
+ }
+
+ public class ObjWithDateTimeOffset
+ {
+ public DateTimeOffset Stamp { get; set; }
+ }
+ }
+}