mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/ExportTests.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.ComponentModel.Composition.Factories;\r
   7 using System.UnitTesting;\r
   8 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
   9 using System.ComponentModel.Composition.Primitives;\r
  10 \r
  11 namespace System.ComponentModel.Composition\r
  12 {\r
  13     [TestClass]\r
  14     public class ExportTests\r
  15     {\r
  16         [TestMethod]\r
  17         public void Constructor1_ShouldNotThrow()\r
  18         {\r
  19             new NoOverridesExport();\r
  20         }\r
  21 \r
  22         [TestMethod]\r
  23         public void Constructor2_NullAsExportedValueGetterArgument_ShouldThrowArgumentNull()\r
  24         {\r
  25             var definition = ExportDefinitionFactory.Create();\r
  26 \r
  27             ExceptionAssert.ThrowsArgument<ArgumentNullException>("exportedValueGetter", () =>\r
  28             {\r
  29                 new Export(definition, (Func<object>)null);\r
  30             });\r
  31         }\r
  32 \r
  33         [TestMethod]\r
  34         public void Constructor3_NullAsExportedValueGetterArgument_ShouldThrowArgumentNull()\r
  35         {\r
  36             ExceptionAssert.ThrowsArgument<ArgumentNullException>("exportedValueGetter", () =>\r
  37             {\r
  38                 new Export("ContractName", (Func<object>)null);\r
  39             });\r
  40         }\r
  41 \r
  42         [TestMethod]\r
  43         public void Constructor4_NullAsExportedValueGetterArgument_ShouldThrowArgumentNull()\r
  44         {\r
  45             var metadata = new Dictionary<string, object>();\r
  46 \r
  47             ExceptionAssert.ThrowsArgument<ArgumentNullException>("exportedValueGetter", () =>\r
  48             {\r
  49                 new Export("ContractName", metadata, (Func<object>)null);\r
  50             });\r
  51         }\r
  52 \r
  53         [TestMethod]\r
  54         public void Constructor2_NullAsDefinitionArgument_ShouldThrowArgumentNull()\r
  55         {\r
  56             ExceptionAssert.ThrowsArgument<ArgumentNullException>("definition", () =>\r
  57             {\r
  58                 new Export((ExportDefinition)null, () => null);\r
  59             });\r
  60         }\r
  61 \r
  62         [TestMethod]\r
  63         public void Constructor2_DefinitionAsDefinitionArgument_ShouldSetDefinitionProperty()\r
  64         {\r
  65             var definition = ExportDefinitionFactory.Create();\r
  66 \r
  67             var export = new Export(definition, () => null);\r
  68 \r
  69             Assert.AreSame(definition, export.Definition);\r
  70         }\r
  71 \r
  72         [TestMethod]\r
  73         public void Constructor3_NullAsContractNameArgument_ShouldThrowArgumentNull()\r
  74         {\r
  75             ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () =>\r
  76             {\r
  77                 new Export((string)null, () => null);\r
  78             });\r
  79         }\r
  80 \r
  81         [TestMethod]\r
  82         public void Constructor4_NullAsContractNameArgument_ShouldThrowArgumentNull()\r
  83         {\r
  84             ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () =>\r
  85             {\r
  86                 new Export((string)null, new Dictionary<string, object>(), () => null);\r
  87             });\r
  88         }\r
  89 \r
  90         [TestMethod]\r
  91         public void Constructor3_EmptyStringAsContractNameArgument_ShouldThrowArgument()\r
  92         {\r
  93             ExceptionAssert.ThrowsArgument<ArgumentException>("contractName", () =>\r
  94             {\r
  95                 new Export(string.Empty, () => null);\r
  96             });\r
  97         }\r
  98 \r
  99         [TestMethod]\r
 100         public void Constructor4_EmptyStringAsContractNameArgument_ShouldThrowArgument()\r
 101         {\r
 102             ExceptionAssert.ThrowsArgument<ArgumentException>("contractName", () =>\r
 103             {\r
 104                 new Export(string.Empty, new Dictionary<string, object>(), () => null);\r
 105             });\r
 106         }\r
 107 \r
 108         [TestMethod]\r
 109         public void Constructor3_ValueAsContractNameArgument_ShouldSetDefinitionContractNameProperty()\r
 110         {\r
 111             var expectations = Expectations.GetContractNames();\r
 112 \r
 113             foreach (var e in expectations)\r
 114             {\r
 115                 var export = new Export(e, () => null);\r
 116 \r
 117                 Assert.AreEqual(e, export.Definition.ContractName);\r
 118             }\r
 119         }\r
 120 \r
 121 \r
 122         [TestMethod]\r
 123         public void Constructor4_ValueAsContractNameArgument_ShouldSetDefinitionContractNameProperty()\r
 124         {\r
 125             var expectations = Expectations.GetContractNames();\r
 126 \r
 127             foreach (var e in expectations)\r
 128             {\r
 129                 var export = new Export(e, new Dictionary<string, object>(), () => null);\r
 130 \r
 131                 Assert.AreEqual(e, export.Definition.ContractName);\r
 132             }\r
 133         }\r
 134 \r
 135         [TestMethod]\r
 136         public void Constructor3_ShouldSetMetadataPropertyToEmptyDictionary()\r
 137         {\r
 138             var export = new Export("ContractName", () => null); ;\r
 139 \r
 140             EnumerableAssert.IsEmpty(export.Metadata);\r
 141         }\r
 142 \r
 143         [TestMethod]\r
 144         public void Constructor4_NullAsMetadataArgument_ShouldSetMetadataPropertyToEmptyDictionary()\r
 145         {\r
 146             var export = new Export("ContractName", (IDictionary<string, object>)null, () => null); ;\r
 147 \r
 148             EnumerableAssert.IsEmpty(export.Metadata);\r
 149         }\r
 150 \r
 151         [TestMethod]\r
 152         public void Constructor3_NullAsMetadataArgument_ShouldSetMetadataPropertyToReadOnlyDictionary()\r
 153         {\r
 154             var export = new Export("ContractName", () => null);\r
 155 \r
 156             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 157             {\r
 158                 export.Metadata["Value"] = "Value";\r
 159             });\r
 160         }\r
 161 \r
 162         [TestMethod]\r
 163         public void Constructor4_NullAsMetadataArgument_ShouldSetMetadataPropertyToReadOnlyDictionary()\r
 164         {\r
 165             var export = new Export("ContractName", (IDictionary<string, object>)null, () => null);\r
 166 \r
 167             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 168             {\r
 169                 export.Metadata["Value"] = "Value";\r
 170             });\r
 171         }\r
 172 \r
 173         [TestMethod]\r
 174         public void Constructor4_WritableDictionaryAsMetadataArgument_ShouldSetMetadataPropertyToReadOnlyDictionary()\r
 175         {\r
 176             var export = new Export("ContractName", new Dictionary<string, object>(), () => null);\r
 177 \r
 178             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 179             {\r
 180                 export.Metadata["Value"] = "Value";\r
 181             });\r
 182         }\r
 183 \r
 184         [TestMethod]\r
 185         public void Constructor4_DictionaryAsMetadataArgument_ShouldSetMetadataProperty()\r
 186         {\r
 187             var expectations = Expectations.GetMetadata();\r
 188 \r
 189             foreach (var e in expectations)\r
 190             {\r
 191                 var export = new Export("ContractName", e, () => null);\r
 192 \r
 193                 EnumerableAssert.AreEqual(e, export.Metadata);\r
 194             }\r
 195         }\r
 196 \r
 197         [TestMethod]\r
 198         public void Constructor3_ShouldSetDefinitionMetadataPropertyToEmptyDictionary()\r
 199         {\r
 200             var export = new Export("ContractName", () => null); ;\r
 201 \r
 202             EnumerableAssert.IsEmpty(export.Definition.Metadata);\r
 203         }\r
 204 \r
 205         [TestMethod]\r
 206         public void Constructor4_NullAsMetadataArgument_ShouldSetDefinitionMetadataPropertyToEmptyDictionary()\r
 207         {\r
 208             var export = new Export("ContractName", (IDictionary<string, object>)null, () => null); ;\r
 209 \r
 210             EnumerableAssert.IsEmpty(export.Definition.Metadata);\r
 211         }\r
 212 \r
 213         [TestMethod]\r
 214         public void Constructor3_ShouldSetDefinitionMetadataPropertyToReadOnlyDictionary()\r
 215         {\r
 216             var export = new Export("ContractName", () => null);\r
 217 \r
 218             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 219             {\r
 220                 export.Definition.Metadata["Value"] = "Value";\r
 221             });\r
 222         }\r
 223 \r
 224         [TestMethod]\r
 225         public void Constructor4_NullAsMetadataArgument_ShouldSetDefinitionMetadataPropertyToReadOnlyDictionary()\r
 226         {\r
 227             var export = new Export("ContractName", (IDictionary<string, object>)null, () => null);\r
 228 \r
 229             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 230             {\r
 231                 export.Definition.Metadata["Value"] = "Value";\r
 232             });\r
 233         }\r
 234 \r
 235         [TestMethod]\r
 236         public void Constructor4_WritableDictionaryAsMetadataArgument_ShouldSetDefinitionMetadataPropertyToReadOnlyDictionary()\r
 237         {\r
 238             var export = new Export("ContractName", new Dictionary<string, object>(), () => null);\r
 239 \r
 240             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 241             {\r
 242                 export.Definition.Metadata["Value"] = "Value";\r
 243             });\r
 244         }\r
 245 \r
 246         [TestMethod]\r
 247         public void Constructor4_DictionaryAsMetadataArgument_ShouldSetDefinitionMetadataProperty()\r
 248         {\r
 249             var expectations = Expectations.GetMetadata();\r
 250 \r
 251             foreach (var e in expectations)\r
 252             {\r
 253                 var export = new Export("ContractName", e, () => null);\r
 254 \r
 255                 EnumerableAssert.AreEqual(e, export.Definition.Metadata);\r
 256             }\r
 257         }\r
 258 \r
 259         [TestMethod]\r
 260         public void Constructor2_FuncReturningAStringAsExportedValueGetter_ShouldBeReturnedByGetExportedValue()\r
 261         {\r
 262             var definition = ExportDefinitionFactory.Create();\r
 263 \r
 264             var export = new Export(definition, () => "Value");\r
 265 \r
 266             Assert.AreEqual("Value", export.Value);\r
 267         }\r
 268 \r
 269         [TestMethod]\r
 270         public void Constructor3_FuncReturningAStringAsExportedValueGetter_ShouldBeReturnedByGetExportedValue()\r
 271         {\r
 272             var export = new Export("ContractName", () => "Value");\r
 273 \r
 274             Assert.AreEqual("Value", export.Value);\r
 275         }\r
 276 \r
 277         [TestMethod]\r
 278         public void Constructor4_FuncReturningAStringAsExportedValueGetter_ShouldBeReturnedByGetExportedValue()\r
 279         {\r
 280             var export = new Export("ContractName", new Dictionary<string, object>(), () => "Value");\r
 281 \r
 282             Assert.AreEqual("Value", export.Value);\r
 283         }\r
 284 \r
 285         [TestMethod]\r
 286         public void Constructor2_FuncReturningNullAsExportedValueGetter_ShouldBeReturnedByGetExportedValue()\r
 287         {\r
 288             var definition = ExportDefinitionFactory.Create();\r
 289 \r
 290             var export = new Export(definition, () => null);\r
 291 \r
 292             Assert.IsNull(export.Value);\r
 293         }\r
 294 \r
 295         [TestMethod]\r
 296         public void Constructor3_FuncReturningNullAsExportedValueGetter_ShouldBeReturnedByGetExportedValue()\r
 297         {\r
 298             var export = new Export("ContractName", () => null);\r
 299 \r
 300             Assert.IsNull(export.Value);\r
 301         }\r
 302 \r
 303         [TestMethod]\r
 304         public void Constructor4_FuncReturningNullAsExportedValueGetter_ShouldBeReturnedByGetExportedValue()\r
 305         {\r
 306             var export = new Export("ContractName", new Dictionary<string, object>(), () => null);\r
 307 \r
 308             Assert.IsNull(export.Value);\r
 309         }\r
 310 \r
 311         [TestMethod]\r
 312         public void Metadata_DerivedExportDefinition_ShouldReturnDefinitionMetadata()\r
 313         {\r
 314             var expectations = Expectations.GetMetadata();\r
 315 \r
 316             foreach (var e in expectations)\r
 317             {\r
 318                 var definition = ExportDefinitionFactory.Create("ContractName", e);\r
 319 \r
 320                 var export = new DerivedExport(definition);\r
 321 \r
 322                 EnumerableAssert.AreEqual(e, export.Metadata);\r
 323             }\r
 324         }\r
 325 \r
 326         [TestMethod]\r
 327         public void Definition_WhenNotOverridden_ShouldThrowNotImplemented()\r
 328         {\r
 329             var export = new NoOverridesExport();\r
 330 \r
 331             ExceptionAssert.Throws<NotImplementedException>(() =>\r
 332             {\r
 333                 var definition = export.Definition;\r
 334             });\r
 335         }\r
 336 \r
 337         [TestMethod]\r
 338         public void Metadata_WhenDefinitionNotOverridden_ShouldThrowNotImplemented()\r
 339         {\r
 340             var export = new NoOverridesExport();\r
 341 \r
 342             ExceptionAssert.Throws<NotImplementedException>(() =>\r
 343             {\r
 344                 var definition = export.Metadata;\r
 345             });\r
 346         }\r
 347 \r
 348         [TestMethod]\r
 349         public void GetExportedValue_WhenGetExportedValueCoreNotOverridden_ShouldThrowNotImplemented()\r
 350         {\r
 351             var export = new NoOverridesExport();\r
 352 \r
 353             ExceptionAssert.Throws<NotImplementedException>(() =>\r
 354             {\r
 355                 var value = export.Value;\r
 356             });\r
 357         }\r
 358 \r
 359         [TestMethod]\r
 360         public void GetExportedValue_ShouldCacheExportedValueGetter()\r
 361         {\r
 362             int count = 0;\r
 363 \r
 364             var export = new Export("ContractName", () =>\r
 365                 {\r
 366                     count++;\r
 367                     return count;\r
 368                 });\r
 369 \r
 370             Assert.AreEqual(1, export.Value);\r
 371             Assert.AreEqual(1, export.Value);\r
 372             Assert.AreEqual(1, export.Value);\r
 373         }\r
 374 \r
 375         \r
 376         [TestMethod]\r
 377         public void GetExportedValue_ShouldCacheOverrideGetExportedValueCore()\r
 378         {\r
 379             int count = 0;\r
 380 \r
 381             var export = new DerivedExport(() =>\r
 382             {\r
 383                 count++;\r
 384                 return count;\r
 385             });\r
 386 \r
 387             Assert.AreEqual(1, export.Value);\r
 388             Assert.AreEqual(1, export.Value);\r
 389             Assert.AreEqual(1, export.Value);\r
 390         }\r
 391 \r
 392         [TestMethod]\r
 393         public void GetExportedValue_ThrowingFuncAsObjectGetterArgument_ShouldThrow()\r
 394         {\r
 395             var exceptionToThrow = new Exception();\r
 396 \r
 397             var export = new Export("ContractName", new Dictionary<string, object>(), () =>\r
 398             {\r
 399                 throw exceptionToThrow;\r
 400             });\r
 401 \r
 402             ExceptionAssert.Throws(exceptionToThrow, RetryMode.Retry, () =>\r
 403             {\r
 404                 var value = export.Value;\r
 405             });\r
 406         }\r
 407 \r
 408 \r
 409         private class NoOverridesExport : Export\r
 410         {\r
 411         }\r
 412 \r
 413         private class DerivedExport : Export\r
 414         {\r
 415             private readonly Func<object> _exportedValueGetter;\r
 416             private readonly ExportDefinition _definition;\r
 417 \r
 418             public DerivedExport(ExportDefinition definition)\r
 419             {\r
 420                 _definition = definition;\r
 421             }\r
 422 \r
 423             public DerivedExport(Func<object> exportedValueGetter)\r
 424             {\r
 425                 _exportedValueGetter = exportedValueGetter;\r
 426             }\r
 427 \r
 428             public override ExportDefinition Definition\r
 429             {\r
 430                 get { return _definition; }\r
 431             }\r
 432 \r
 433             protected override object GetExportedValueCore()\r
 434             {\r
 435                 return _exportedValueGetter();\r
 436             }\r
 437         }\r
 438     }\r
 439 }\r