added unit test and updated readme.md

Author: jeevasusej

.gitignore

@@ -16,3 +16,4 @@
 /ValueMapper/ValueMapperCore/bin
 /ValueMapper/ValueMapperCore/obj
 /ValueMapper/.vs
+/ValueMapper/Benchmark/BenchmarkDotNet.Artifacts

README.md

@@ -2,29 +2,14 @@
 
 A high-performance, lightweight object-to-object mapper for .NET with zero dependencies. ValueMapper provides fast mapping capabilities with a simple API, making it easy to map between different object types while maintaining good performance.
 
-## Features
-
-- ⚙️ Zero configuration required
-- ✨ Zero dependencies
-- 🚀 High performance
-- 💡 Simple API
-- 🔄 Automatic type conversion
-- 🏷️ Custom property mapping via attributes
-- ⏭️ Property ignoring
-- 📝 Collection mapping
-- 🔄 Enum mapping (case-insensitive)
-- 🧵 Parallel collection mapping for large datasets
-- 🔒 Thread-safe operation
-- 🔥 Mapping compilation caching
-
 ## Feature Comparison
 
 | Feature                      | ValueMapper         | Mapster       | AutoMapper     |
 | ---------------------------- | ------------------- | ------------- | -------------- |
 | Zero Dependencies            | ✅                  | ✅            | ❌             |
 | Basic Property Mapping       | ✅                  | ✅            | ✅             |
 | Flattening                   | ❌                  | ✅            | ✅             |
-| Deep Object Mapping          | ❌                  | ✅            | ✅             |
+| Deep Object Mapping          | ✅                  | ✅            | ✅             |
 | Collection Mapping           | ✅                  | ✅            | ✅             |
 | Enum Mapping                 | ✅                  | ✅            | ✅             |
 | Custom Property Mapping      | ✅ (attr)           | ✅            | ✅             |
@@ -46,7 +31,23 @@ A high-performance, lightweight object-to-object mapper for .NET with zero depen
 
 \* Based on benchmark results for single object mapping. For collection mapping (100,000 items), ValueMapper performs better: ValueMapper (39.84ms), Mapster (65.34ms), AutoMapper (70.80ms).
 
-## Installation - [nuget](https://www.nuget.org/packages/ValueMapper)
+- Can be implemented manually
+
+## Features
+
+- ✨ Zero dependencies
+- 🚀 High performance
+- 💡 Simple API
+- 🔄 Automatic type conversion
+- 🏷️ Custom property mapping via attributes
+- ⏭️ Property ignoring
+- 📝 Collection mapping
+- 🔄 Enum mapping (case-insensitive)
+- 🧵 Parallel collection mapping for large datasets
+- 🔒 Thread-safe operation
+- 🔥 Mapping compilation caching
+
+## Installation
 
 ```shell
 dotnet add package ValueMapper
@@ -166,6 +167,75 @@ public class Destination
 }
 ```
 
+### Deep Object Mapping
+
+ValueMapper supports mapping nested objects with multiple levels of depth, including collections and dictionaries:
+
+```csharp
+public class DeepSourceObject
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public DeepSourceChild Child { get; set; }
+}
+
+public class DeepSourceChild
+{
+    public int ChildId { get; set; }
+    public string Description { get; set; }
+    public Dictionary<string, string> Metadata { get; set; }
+    public List<string> Tags { get; set; }
+    public DeepSourceGrandChild GrandChild { get; set; }
+}
+
+public class DeepSourceGrandChild
+{
+    public int GrandChildId { get; set; }
+    public bool IsActive { get; set; }
+    public DateTime CreatedDate { get; set; }
+}
+
+// Destination classes with matching structure
+public class DeepDestinationObject
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+    public DeepDestinationChild Child { get; set; }
+}
+
+// ... similar structure for DeepDestinationChild and DeepDestinationGrandChild
+
+var source = new DeepSourceObject
+{
+    Id = 1,
+    Name = "Root Object",
+    Child = new DeepSourceChild
+    {
+        ChildId = 100,
+        Description = "Child Object",
+        Metadata = new Dictionary<string, string> { { "key1", "value1" } },
+        Tags = new List<string> { "tag1", "tag2" },
+        GrandChild = new DeepSourceGrandChild
+        {
+            GrandChildId = 1000,
+            IsActive = true,
+            CreatedDate = new DateTime(2024, 1, 1)
+        }
+    }
+};
+
+var destination = ValueMapper.Map<DeepSourceObject, DeepDestinationObject>(source);
+// All nested objects are automatically mapped
+```
+
+**Collection Mapping Behavior:**
+- **Lists**: Creates new List instances (shallow copy - same objects, new container)
+  - Null sources become empty lists `[]`
+- **Dictionaries**: Copies references (same instance)
+  - Null sources remain null
+- **Complex Objects**: Deep mapping with new instances
+- **Primitive Types**: Direct value copying
+
 ## Performance
 
 ValueMapper is designed for high performance. Here are some benchmark results comparing it with other popular mappers:
@@ -243,16 +313,11 @@ ValueMapper.Clear<Source, Destination>();
 
 ## Known Limitations
 
-1. Deep object mapping is not currently supported
-
-   - The `Map_DeepObjectMapping_ShouldMapCorrectly` test demonstrates this limitation
-   - Complex nested objects with multiple levels are not automatically mapped
-
-2. No circular reference detection
-3. No support for mapping private properties
-4. Collection type conversion (e.g., List<T> to Array<T>) is not supported
-5. No support for custom value converters
-6. No support for conditional mapping
+1. No circular reference detection
+2. No support for mapping private properties
+3. Collection type conversion (e.g., List<T> to Array<T>) is not supported
+4. No support for custom value converters
+5. No support for conditional mapping
 
 ## Contributing
 

ValueMapper/UnitTestXUnitNet6/TestModels.cs

@@ -149,4 +149,83 @@ public class FlatDestinationObject
         public bool GrandChildIsActive { get; set; }
         public DateTime GrandChildCreatedDate { get; set; }
     }
+
+    // Models for testing complex collections in deep object mapping
+    public class ComplexMetadataItem
+    {
+        public int Id { get; set; }
+        public string Value { get; set; }
+    }
+
+    public class ComplexTag
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public bool IsActive { get; set; }
+    }
+
+    public class DeepSourceObjectWithComplexCollections
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public DeepSourceChildWithComplexCollections Child { get; set; }
+    }
+
+    public class DeepSourceChildWithComplexCollections
+    {
+        public int ChildId { get; set; }
+        public string Description { get; set; }
+        public Dictionary<string, ComplexMetadataItem> ComplexMetadata { get; set; }
+        public List<ComplexTag> ComplexTags { get; set; }
+        public DeepSourceGrandChild GrandChild { get; set; }
+    }
+
+    public class DeepDestinationObjectWithComplexCollections
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public DeepDestinationChildWithComplexCollections Child { get; set; }
+    }
+
+    public class DeepDestinationChildWithComplexCollections
+    {
+        public int ChildId { get; set; }
+        public string Description { get; set; }
+        public Dictionary<string, ComplexMetadataItem> ComplexMetadata { get; set; }
+        public List<ComplexTag> ComplexTags { get; set; }
+        public DeepDestinationGrandChild GrandChild { get; set; }
+    }
+
+    // Models for testing nested collections in deep object mapping
+    public class DeepSourceObjectWithNestedCollections
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public DeepSourceChildWithNestedCollections Child { get; set; }
+    }
+
+    public class DeepSourceChildWithNestedCollections
+    {
+        public int ChildId { get; set; }
+        public string Description { get; set; }
+        public Dictionary<string, List<string>> NestedMetadata { get; set; }
+        public List<List<string>> NestedTags { get; set; }
+        public DeepSourceGrandChild GrandChild { get; set; }
+    }
+
+    public class DeepDestinationObjectWithNestedCollections
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public DeepDestinationChildWithNestedCollections Child { get; set; }
+    }
+
+    public class DeepDestinationChildWithNestedCollections
+    {
+        public int ChildId { get; set; }
+        public string Description { get; set; }
+        public Dictionary<string, List<string>> NestedMetadata { get; set; }
+        public List<List<string>> NestedTags { get; set; }
+        public DeepDestinationGrandChild GrandChild { get; set; }
+    }
 }