mcs/class/System.ComponentModel.Composition/Tests/UnitTestFramework/System/UnitTesting/EnumerableAssert.cs

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Collections.Generic;\r
   6 using System.Linq;\r
   7 using System.Collections;\r
   8 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
   9 using Microsoft.Internal.Collections;\r
  10 \r
  11 namespace System.UnitTesting\r
  12 {\r
  13     public static class EnumerableAssert\r
  14     {\r
  15         public static void IsTrueForAll<T>(IEnumerable<T> source, Predicate<T> predicate)\r
  16         {\r
  17             IsTrueForAll(source, predicate, "IsTrueForAll Failed");\r
  18         }\r
  19 \r
  20         public static void IsTrueForAll<T>(IEnumerable<T> source, Predicate<T> predicate, string message)\r
  21         {\r
  22             Assert.IsNotNull(source, "Source should not be null!");\r
  23 \r
  24             foreach (T t in source)\r
  25             {\r
  26                 Assert.IsTrue(predicate(t), message);\r
  27             }\r
  28         }\r
  29 \r
  30         // Needed to prevent strings from matching to the plain IEnumerable overload\r
  31         public static void AreEqual(IEnumerable actual, params string[] expected)\r
  32         {\r
  33             AreEqual((IEnumerable)expected, (IEnumerable)actual);\r
  34         }\r
  35 \r
  36         public static void AreEqual(IEnumerable actual, params object[] expected)\r
  37         {\r
  38             AreEqual((IEnumerable)expected, (IEnumerable)actual);\r
  39         }\r
  40 \r
  41         public static void AreEqual<T>(IEnumerable<T> actual, params T[] expected)\r
  42         {\r
  43             AreEqual<T>((IEnumerable<T>)expected, (IEnumerable<T>)actual);\r
  44         }\r
  45 \r
  46         public static void AreEqual(IEnumerable expected, IEnumerable actual)\r
  47         {\r
  48             Assert.AreEqual(expected.Count(), actual.Count(), "Enumerable should contain the correct number of items");\r
  49 \r
  50             List<object> actualList = actual.ToList();\r
  51 \r
  52             foreach (object value in expected)\r
  53             {\r
  54                 bool removed = actualList.Remove(value);\r
  55 \r
  56                 Assert.IsTrue(removed, "Enumerable does not contain value {0}.", value);\r
  57             }\r
  58 \r
  59             Assert.AreEqual(0, actualList.Count, "Enumerable contains extra values.");\r
  60         }\r
  61 \r
  62         public static void AreEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual)\r
  63         {\r
  64             // First, test the IEnumerable implementation\r
  65             AreEqual((IEnumerable)expected, (IEnumerable)actual);\r
  66 \r
  67             // Second, test the IEnumerable<T> implementation\r
  68             Assert.AreEqual(expected.Count(), actual.Count(), "Enumerable should contain the correct number of items");\r
  69 \r
  70             List<T> actualList = actual.ToList();\r
  71 \r
  72             foreach (T value in expected)\r
  73             {\r
  74                 bool removed = actualList.Remove(value);\r
  75 \r
  76                 Assert.IsTrue(removed, "Enumerable does not contain value {0}.", value);\r
  77             }\r
  78 \r
  79             Assert.AreEqual(0, actualList.Count, "Enumerable contains extra values.");\r
  80         }\r
  81 \r
  82         // Needed to prevent strings from matching to the plain IEnumerable overload\r
  83         public static void AreSequenceEqual(IEnumerable actual, params string[] expected)\r
  84         {   \r
  85             AreEqual((IEnumerable)expected, (IEnumerable)actual);\r
  86         }\r
  87 \r
  88         public static void AreSequenceEqual(IEnumerable actual, params object[] expected)\r
  89         {\r
  90             AreEqual((IEnumerable)expected, (IEnumerable)actual);\r
  91         }\r
  92 \r
  93         public static void AreSequenceEqual(IEnumerable expected, IEnumerable actual)\r
  94         {\r
  95             AreSequenceEqual(expected, actual, (Action<int, object, object>)null);\r
  96         }\r
  97 \r
  98         public static void AreSequenceEqual(IEnumerable expected, IEnumerable actual, Action<int, object, object> comparer)\r
  99         {\r
 100             if (comparer == null)\r
 101             {\r
 102                 comparer = (i, left, right) => Assert.AreEqual(left, right, "Enumerable at index {0} should have same value", i);\r
 103             }\r
 104 \r
 105             int expectedCount = expected.Count();\r
 106 \r
 107             Assert.AreEqual(expectedCount, actual.Count(), "Enumerable should contain the correct number of items");\r
 108 \r
 109             IEnumerator actualEnumerator = actual.GetEnumerator();\r
 110             IEnumerator expectedEnumerator = expected.GetEnumerator();\r
 111 \r
 112             int index = 0;\r
 113             while (index < expectedCount)\r
 114             {\r
 115                 Assert.IsTrue(actualEnumerator.MoveNext());\r
 116                 Assert.IsTrue(expectedEnumerator.MoveNext());\r
 117 \r
 118                 comparer(index, expectedEnumerator.Current, actualEnumerator.Current);\r
 119                 index++;\r
 120             }\r
 121         }\r
 122 \r
 123         public static void AreSequenceEqual<T>(IEnumerable<T> actual, params T[] expected)\r
 124         {\r
 125             AreSequenceEqual<T>((IEnumerable<T>)expected, (IEnumerable<T>)actual);\r
 126         }\r
 127 \r
 128         public static void AreSequenceEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual)\r
 129         {\r
 130             AreSequenceEqual<T>(expected, actual, (Action<int, T, T>)null);\r
 131         }\r
 132 \r
 133         public static void AreSequenceEqual<T>(IEnumerable<T> expected, IEnumerable<T> actual, Action<int, T, T> comparer)\r
 134         {\r
 135             if (comparer == null)\r
 136             {\r
 137                 comparer = (i, left, right) => Assert.AreEqual(left, right, "Enumerable at index {0} should have same value", i);\r
 138             }\r
 139 \r
 140             // First, test the IEnumerable implementation\r
 141             AreSequenceEqual((IEnumerable)expected, (IEnumerable)actual, (Action<int, object, object>)((currentIndex, left, right) => comparer(currentIndex, (T)left, (T)right)));\r
 142 \r
 143             // Second, test the IEnumerable<T> implementation\r
 144             int expectedCount = expected.Count();\r
 145 \r
 146             IEnumerator<T> actualEnumerator = actual.GetEnumerator();\r
 147             IEnumerator<T> expectedEnumerator = expected.GetEnumerator();\r
 148 \r
 149             int index = 0;\r
 150             while (index < expectedCount)\r
 151             {\r
 152                 Assert.IsTrue(actualEnumerator.MoveNext());\r
 153                 Assert.IsTrue(expectedEnumerator.MoveNext());\r
 154 \r
 155                 comparer(index, expectedEnumerator.Current, actualEnumerator.Current);                \r
 156                 index++;\r
 157             }\r
 158         }\r
 159 \r
 160         public static void AreSequenceSame<T>(IEnumerable<T> expected, IEnumerable<T> actual)\r
 161         {\r
 162             AreSequenceEqual<T>(expected, actual, (index, left, right) =>\r
 163             {\r
 164                 Assert.AreSame(left, right, "Enumerable at index {0} should have same value", index);\r
 165             });\r
 166         }\r
 167 \r
 168         public static void AreEqual<TKey, TValue>(IDictionary<TKey, TValue> expected, IDictionary<TKey, TValue> actual)\r
 169         {\r
 170             Assert.AreEqual(expected.Count, actual.Count, "Dictionaries are different : first has '{0} elements, whereas second has '{1}", expected.Count, actual.Count);\r
 171 \r
 172             foreach (KeyValuePair<TKey, TValue> kvp in expected)\r
 173             {\r
 174                 TValue firstValue = kvp.Value;\r
 175                 TValue secondValue = default(TValue);\r
 176                 if (!actual.TryGetValue(kvp.Key, out secondValue))\r
 177                 {\r
 178                     Assert.Fail("Dictionaries are different : There is no item with key '{0}' in the second dictionary", kvp.Key);\r
 179                 }\r
 180 \r
 181                 if ((firstValue is IDictionary<TKey, TValue>) && (secondValue is IDictionary<TKey, TValue>))\r
 182                 {\r
 183                     AreEqual((IDictionary<TKey, TValue>)firstValue, (IDictionary<TKey, TValue>)secondValue);\r
 184                     continue;\r
 185                 }\r
 186 \r
 187                 Assert.AreEqual(kvp.Value, secondValue, "Dictionaries are different : values for key '{0}' are different - '{1}' vs '{2}'", kvp.Key, firstValue, secondValue);\r
 188             }\r
 189         }\r
 190 \r
 191         /// <summary>\r
 192         ///     Verifies that the specified enumerable is empty.\r
 193         /// </summary>\r
 194         public static void IsEmpty(IEnumerable source)\r
 195         {\r
 196             IsEmpty(source, null);\r
 197         }\r
 198 \r
 199         public static void IsEmpty(IEnumerable source, string message)\r
 200         {\r
 201             Assert.AreEqual(0, source.Count(), message);\r
 202         }\r
 203     }\r
 204 }\r