mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/Microsoft/Internal/Collections/ReadOnlyDictionaryTests.cs

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Collections;\r
   6 using System.Collections.Generic;\r
   7 using System.UnitTesting;\r
   8 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
   9 \r
  10 namespace Microsoft.Internal.Collections\r
  11 {\r
  12     [TestClass]\r
  13     public class ReadOnlyDictionaryTests\r
  14     {\r
  15         [TestMethod]\r
  16         public void Constructor_NullAsDictionaryArgument_ShouldCreateEmptyDictionary()\r
  17         {\r
  18             var dictionary = new ReadOnlyDictionary<string, object>(null);\r
  19 \r
  20             EnumerableAssert.IsEmpty(dictionary);\r
  21         }\r
  22 \r
  23         [TestMethod]\r
  24         public void Constructor_WritableDictionaryAsDictionaryArgument_ShouldPopulateCollection()\r
  25         {\r
  26             var dictionary = GetWritableDictionaryWithData();\r
  27             var readOnlyDictionary = new ReadOnlyDictionary<string, object>(dictionary);\r
  28 \r
  29             EnumerableAssert.AreEqual(dictionary, readOnlyDictionary);\r
  30         }\r
  31 \r
  32         [TestMethod]\r
  33         public void Add1_ShouldThrowNotSupported()\r
  34         {\r
  35             var dictionary = GetReadOnlyDictionaryWithData();\r
  36 \r
  37             ExceptionAssert.Throws<NotSupportedException>(() =>\r
  38             {\r
  39                 dictionary.Add(new KeyValuePair<string, object>("Key", "Value"));\r
  40             });\r
  41         }\r
  42 \r
  43         [TestMethod]\r
  44         public void Add2_ShouldThrowNotSupported()\r
  45         {\r
  46             var dictionary = GetReadOnlyDictionaryWithData();\r
  47 \r
  48             ExceptionAssert.Throws<NotSupportedException>(() =>\r
  49             {\r
  50                 dictionary.Add("Key", "Value");\r
  51             });\r
  52         }\r
  53 \r
  54         [TestMethod]\r
  55         public void Clear_ShouldThrowNotSupported()\r
  56         {\r
  57             var dictionary = GetReadOnlyDictionaryWithData();\r
  58 \r
  59             ExceptionAssert.Throws<NotSupportedException>(() =>\r
  60             {\r
  61                 dictionary.Clear();\r
  62             });\r
  63         }\r
  64 \r
  65         [TestMethod]\r
  66         public void Remove1_ShouldThrowNotSupported()\r
  67         {\r
  68             var dictionary = GetReadOnlyDictionaryWithData();\r
  69 \r
  70             ExceptionAssert.Throws<NotSupportedException>(() =>\r
  71             {\r
  72                 dictionary.Remove("Value");\r
  73             });\r
  74         }\r
  75 \r
  76         [TestMethod]\r
  77         public void Remove2_ShouldThrowNotSupported()\r
  78         {\r
  79             var dictionary = GetReadOnlyDictionaryWithData();\r
  80 \r
  81             ExceptionAssert.Throws<NotSupportedException>(() =>\r
  82             {\r
  83                 dictionary.Remove(new KeyValuePair<string, object>("Key", "Value"));\r
  84             });\r
  85         }\r
  86 \r
  87         [TestMethod]\r
  88         public void ItemSet_ShouldThrowNotSupported()\r
  89         {\r
  90             var dictionary = GetReadOnlyDictionaryWithData();\r
  91 \r
  92             ExceptionAssert.Throws<NotSupportedException>(() =>\r
  93             {\r
  94                 dictionary["Key"] = "Value";\r
  95             });\r
  96         }\r
  97 \r
  98         [TestMethod]\r
  99         public void Keys_ShouldReturnWrappedDictionaryKeys()\r
 100         {\r
 101             var dictionary = GetWritableDictionaryWithData();\r
 102             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 103 \r
 104             EnumerableAssert.AreEqual(readOnlyDictionary.Keys, dictionary.Keys);\r
 105         }\r
 106 \r
 107         [TestMethod]\r
 108         public void Values_ShouldReturnWrappedDictionaryValues()\r
 109         {\r
 110             var dictionary = GetWritableDictionaryWithData();\r
 111             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 112 \r
 113             EnumerableAssert.AreEqual(readOnlyDictionary.Values, readOnlyDictionary.Values);\r
 114         }\r
 115 \r
 116         [TestMethod]\r
 117         public void IsReadOnly_ShouldAlwaysBeTrue()\r
 118         {\r
 119             var dictionary = GetWritableDictionaryWithData();\r
 120             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 121             \r
 122             Assert.IsFalse(dictionary.IsReadOnly);\r
 123             Assert.IsTrue(readOnlyDictionary.IsReadOnly);\r
 124         }\r
 125 \r
 126         [TestMethod]\r
 127         public void Count_ShouldReturnWrappedDictionaryCount()\r
 128         {\r
 129             var dictionary = GetWritableDictionaryWithData();\r
 130             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 131 \r
 132             Assert.AreEqual(dictionary.Count, readOnlyDictionary.Count);\r
 133         }\r
 134 \r
 135         [TestMethod]\r
 136         public void ContainsKey()\r
 137         {\r
 138             var dictionary = GetWritableDictionaryWithData();\r
 139             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 140 \r
 141             Assert.IsTrue(readOnlyDictionary.ContainsKey("Key1"));\r
 142             Assert.IsFalse(readOnlyDictionary.ContainsKey("InvalidKey"));\r
 143         }\r
 144 \r
 145         [TestMethod]\r
 146         public void Contains()\r
 147         {\r
 148             var dictionary = GetWritableDictionaryWithData();\r
 149             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 150 \r
 151             Assert.IsTrue(readOnlyDictionary.Contains(new KeyValuePair<string,object>("Key1", "Value1")));\r
 152             Assert.IsFalse(readOnlyDictionary.Contains(new KeyValuePair<string,object>("InvalidKey", "Value1")));\r
 153             Assert.IsFalse(readOnlyDictionary.Contains(new KeyValuePair<string,object>("Key1", "InvalidValue")));\r
 154         }\r
 155 \r
 156         [TestMethod]\r
 157         public void CopyTo()\r
 158         {\r
 159             var dictionary = GetWritableDictionaryWithData();\r
 160             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 161             KeyValuePair<string, object>[] destination = new KeyValuePair<string, object> [readOnlyDictionary.Count];\r
 162             readOnlyDictionary.CopyTo(destination, 0);\r
 163             EnumerableAssert.AreEqual(readOnlyDictionary, destination);\r
 164         }\r
 165 \r
 166         [TestMethod]\r
 167         public void GetEnumerator()\r
 168         {\r
 169             var dictionary = GetWritableDictionaryWithData();\r
 170             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 171             IEnumerable<KeyValuePair<string, object>> genericEnumerable = readOnlyDictionary;\r
 172             EnumerableAssert.AreEqual(genericEnumerable, dictionary);\r
 173             IEnumerable weakEnumerable = (IEnumerable)readOnlyDictionary;\r
 174             EnumerableAssert.AreEqual(weakEnumerable, dictionary);\r
 175         }\r
 176 \r
 177         [TestMethod]\r
 178         public void Item()\r
 179         {\r
 180             var dictionary = GetWritableDictionaryWithData();\r
 181             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 182             Assert.AreEqual("Value1", readOnlyDictionary["Key1"], "Expecting to read wrapped value");\r
 183         }\r
 184 \r
 185         [TestMethod]\r
 186         public void TryGetValue()\r
 187         {\r
 188             var dictionary = GetWritableDictionaryWithData();\r
 189             var readOnlyDictionary = GetReadOnlyDictionary(dictionary);\r
 190             object result;\r
 191             bool ret = readOnlyDictionary.TryGetValue("Key1", out result);\r
 192             Assert.IsTrue(ret, "Expecting TryGetExportedValue to return true for wrapped key");\r
 193             Assert.AreEqual("Value1", result, "Expecting TryGetExportedValue to return wrapped value");\r
 194         }\r
 195 \r
 196         private static IDictionary<String, object> GetReadOnlyDictionaryWithData()\r
 197         {\r
 198             return GetReadOnlyDictionary(GetWritableDictionaryWithData());\r
 199         }\r
 200 \r
 201         private static IDictionary<TKey, TValue> GetReadOnlyDictionary<TKey, TValue>(IDictionary<TKey, TValue> dictionary)\r
 202         {\r
 203             return new ReadOnlyDictionary<TKey, TValue>(dictionary);\r
 204         }\r
 205 \r
 206         private static IDictionary<String, object> GetWritableDictionaryWithData()\r
 207         {\r
 208             IDictionary<String, object> dictionary = new Dictionary<String, object>();\r
 209             dictionary.Add("Key1", "Value1");\r
 210             dictionary.Add("Key2", 42);\r
 211             return dictionary;\r
 212         }\r
 213     }\r
 214 }