Add AOT test for FullObjectGraphTraversalStrategy.

YamlDotNet.AotTest/Program.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using YamlDotNet.Serialization;
 using YamlDotNet.Serialization.NamingConventions;
+using YamlDotNet.Test.Serialization;
 
 namespace YamlDotNet.AotTest
 {
@@ -21,6 +22,7 @@ static int Main(string[] args)
             TryDeserialize<MyDictionary>("DictionaryNodeDeserializer", "myDictionary: { winners: 3 }");
             TryDeserialize<MyList>("CollectionNodeDeserializer", "myList: [ 1, 2, 3 ]");
             TryDeserialize<MyArray>("ArayNodeDeserializer", "myArray: [ 1, 2, 3 ]");
+            TrySerialize("TraverseGenericDictionary", new GenericTestDictionary<long, long> { { 1, 2 } });
 
             Console.WriteLine();
             Console.ForegroundColor = ConsoleColor.White;
@@ -37,17 +39,29 @@ static int Main(string[] args)
         private static int succeededTestCount;
         private static int failedTestCount;
 
+        private static void TrySerialize<T>(string testName, T graph)
+        {
+            var output = new StringWriter();
+            var serializer = new Serializer(namingConvention: new CamelCaseNamingConvention());
+            PerformTest(testName, () => serializer.Serialize(output, graph));
+        }
+
         private static void TryDeserialize<T>(string testName, string yaml)
+        {
+            var input = new StringReader(yaml);
+            var deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention());
+            PerformTest(testName, () => deserializer.Deserialize<T>(input));
+        }
+
+        private static void PerformTest(string testName, Action act)
         {
             Console.ForegroundColor = ConsoleColor.Gray;
             Console.Write(" ");
             Console.Write(testName.PadRight(70));
 
-            var input = new StringReader(yaml);
-            var deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention());
             try
             {
-                deserializer.Deserialize<T>(input);
+                act();
                 Console.ForegroundColor = ConsoleColor.Green;
                 Console.WriteLine("[success]");
                 Console.ForegroundColor = ConsoleColor.Gray;

YamlDotNet.AotTest/YamlDotNet.AotTest.csproj

@@ -27,6 +27,9 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\YamlDotNet.Test\Serialization\GenericTestDictionary.cs">
+      <Link>GenericTestDictionary.cs</Link>
+    </Compile>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
@@ -47,4 +50,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

YamlDotNet.Test/Serialization/GenericTestDictionary.cs

@@ -0,0 +1,119 @@
+//  This file is part of YamlDotNet - A .NET library for YAML.
+//  Copyright (c) Antoine Aubry and contributors
+
+//  Permission is hereby granted, free of charge, to any person obtaining a copy of
+//  this software and associated documentation files (the "Software"), to deal in
+//  the Software without restriction, including without limitation the rights to
+//  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+//  of the Software, and to permit persons to whom the Software is furnished to do
+//  so, subject to the following conditions:
+
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YamlDotNet.Test.Serialization
+{
+    /// <summary>
+    /// Test Dictionary that implements IDictionary<,>, but not IDictionary
+    /// </summary>
+    public class GenericTestDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+    {
+        private readonly Dictionary<TKey, TValue> dictionary;
+
+        public GenericTestDictionary()
+        {
+            dictionary = new Dictionary<TKey, TValue>();
+        }
+        public void Add(TKey key, TValue value)
+        {
+            dictionary.Add(key, value);
+        }
+
+        public bool ContainsKey(TKey key)
+        {
+            return dictionary.ContainsKey(key);
+        }
+
+        public ICollection<TKey> Keys
+        {
+            get { return dictionary.Keys; }
+        }
+
+        public bool Remove(TKey key)
+        {
+            return dictionary.Remove(key);
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            return dictionary.TryGetValue(key, out value);
+        }
+
+        public ICollection<TValue> Values
+        {
+            get { return dictionary.Values; }
+        }
+
+        public TValue this[TKey key]
+        {
+            get { return dictionary[key]; }
+            set { dictionary[key] = value; }
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item)
+        {
+            ((IDictionary<TKey, TValue>)dictionary).Add(item);
+        }
+
+        public void Clear()
+        {
+            dictionary.Clear();
+        }
+
+        public bool Contains(KeyValuePair<TKey, TValue> item)
+        {
+            return ((IDictionary<TKey, TValue>)dictionary).Contains(item);
+        }
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            ((IDictionary<TKey, TValue>)dictionary).CopyTo(array, arrayIndex);
+        }
+
+        public int Count
+        {
+            get { return dictionary.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            return ((IDictionary<TKey, TValue>)dictionary).Remove(item);
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            return dictionary.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return dictionary.GetEnumerator();
+        }
+    }
+}

YamlDotNet.Test/Serialization/GenericTestList.cs

@@ -0,0 +1,111 @@
+//  This file is part of YamlDotNet - A .NET library for YAML.
+//  Copyright (c) Antoine Aubry and contributors
+
+//  Permission is hereby granted, free of charge, to any person obtaining a copy of
+//  this software and associated documentation files (the "Software"), to deal in
+//  the Software without restriction, including without limitation the rights to
+//  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+//  of the Software, and to permit persons to whom the Software is furnished to do
+//  so, subject to the following conditions:
+
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+
+using System.Collections;
+using System.Collections.Generic;
+
+namespace YamlDotNet.Test.Serialization
+{
+    /// <summary>
+    /// Test List that implements IList<>, but not IList
+    /// </summary>
+    public class GenericTestList<T> : IList<T>
+    {
+        private readonly List<T> list;
+
+        public GenericTestList()
+        {
+            list = new List<T>();
+        }
+
+        public int IndexOf(T item)
+        {
+            return list.IndexOf(item);
+        }
+
+        public void Insert(int index, T item)
+        {
+            list.Insert(index, item);
+        }
+
+        public void RemoveAt(int index)
+        {
+            list.RemoveAt(index);
+        }
+
+        public T this[int index]
+        {
+            get
+            {
+                return list[index];
+            }
+            set
+            {
+                list[index] = value;
+            }
+        }
+
+        public void Add(T item)
+        {
+            list.Add(item);
+        }
+
+        public void Clear()
+        {
+            list.Clear();
+        }
+
+        public bool Contains(T item)
+        {
+            return list.Contains(item);
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            list.CopyTo(array, arrayIndex);
+        }
+
+        public int Count
+        {
+            get { return list.Count; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        public bool Remove(T item)
+        {
+            return list.Remove(item);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return list.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return list.GetEnumerator();
+        }
+    }
+}