mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/ReflectionModel/ReflectionModelServicesTests.cs

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.ComponentModel.Composition.Factories;\r
   6 using System.ComponentModel.Composition.Hosting;\r
   7 using System.ComponentModel.Composition.Primitives;\r
   8 using System.Reflection;\r
   9 using Microsoft.Internal;\r
  10 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  11 using System.Collections.Generic;\r
  12 using System.Linq;\r
  13 using System.UnitTesting;\r
  14 using System.Threading;\r
  15 \r
  16 namespace System.ComponentModel.Composition.ReflectionModel\r
  17 {\r
  18     [TestClass]\r
  19     public class ReflectionModelServicesTests\r
  20     {\r
  21         [TestMethod]\r
  22         public void CreatePartDefinition()\r
  23         {\r
  24             Type expectedType = typeof(TestPart);\r
  25             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
  26             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
  27             expectedMetadata["Key1"] = 1;\r
  28             expectedMetadata["Key2"] = "Value2";\r
  29 \r
  30             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
  31             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
  32 \r
  33             ICompositionElement expectedOrigin = new MockOrigin();\r
  34 \r
  35             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
  36                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
  37                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
  38                 expectedMetadata.AsLazy(), expectedOrigin);\r
  39             Assert.IsNotNull(partDefinition);\r
  40 \r
  41             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
  42             Assert.IsNotNull(definition);\r
  43 \r
  44             Assert.AreSame(expectedType, definition.GetPartType());\r
  45             Assert.IsTrue(definition.Metadata.Keys.SequenceEqual(expectedMetadata.Keys));\r
  46             Assert.IsTrue(definition.Metadata.Values.SequenceEqual(expectedMetadata.Values));\r
  47             Assert.IsTrue(definition.ExportDefinitions.SequenceEqual(expectedExports.Cast<ExportDefinition>()));\r
  48             Assert.IsTrue(definition.ImportDefinitions.SequenceEqual(expectedImports.Cast<ImportDefinition>()));\r
  49             Assert.AreSame(expectedOrigin, ((ICompositionElement)definition).Origin);\r
  50             Assert.IsNotNull(((ICompositionElement)definition).DisplayName);\r
  51             Assert.IsFalse(definition.IsDisposalRequired);\r
  52         }\r
  53 \r
  54         [TestMethod]\r
  55         public void CreatePartDefinition_Disposable()\r
  56         {\r
  57             Type expectedType = typeof(TestPart);\r
  58             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
  59             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
  60             expectedMetadata["Key1"] = 1;\r
  61             expectedMetadata["Key2"] = "Value2";\r
  62 \r
  63             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
  64             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
  65 \r
  66             ICompositionElement expectedOrigin = new MockOrigin();\r
  67 \r
  68             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, true,\r
  69                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
  70                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
  71                 expectedMetadata.AsLazy(), expectedOrigin);\r
  72             Assert.IsNotNull(partDefinition);\r
  73 \r
  74             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
  75             Assert.IsNotNull(definition);\r
  76 \r
  77             Assert.AreSame(expectedType, definition.GetPartType());\r
  78             Assert.IsTrue(definition.Metadata.Keys.SequenceEqual(expectedMetadata.Keys));\r
  79             Assert.IsTrue(definition.Metadata.Values.SequenceEqual(expectedMetadata.Values));\r
  80             Assert.IsTrue(definition.ExportDefinitions.SequenceEqual(expectedExports.Cast<ExportDefinition>()));\r
  81             Assert.IsTrue(definition.ImportDefinitions.SequenceEqual(expectedImports.Cast<ImportDefinition>()));\r
  82             Assert.AreSame(expectedOrigin, ((ICompositionElement)definition).Origin);\r
  83             Assert.IsNotNull(((ICompositionElement)definition).DisplayName);\r
  84             Assert.IsTrue(definition.IsDisposalRequired);\r
  85         }\r
  86 \r
  87         [TestMethod]\r
  88         public void CreatePartDefinition_NullMetadataAllowed()\r
  89         {\r
  90             Type expectedType = typeof(TestPart);\r
  91             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
  92 \r
  93             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
  94             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
  95 \r
  96             ICompositionElement expectedOrigin = new MockOrigin();\r
  97 \r
  98             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
  99                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 100                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 101                 null, expectedOrigin);\r
 102             Assert.IsNotNull(partDefinition);\r
 103 \r
 104             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 105             Assert.IsNotNull(definition);\r
 106             Assert.IsNotNull(definition.Metadata);\r
 107             Assert.AreEqual(0, definition.Metadata.Count);\r
 108         }\r
 109 \r
 110         [TestMethod]\r
 111         public void CreatePartDefinition_EvaluatedNullMetadataAllowed()\r
 112         {\r
 113             Type expectedType = typeof(TestPart);\r
 114             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 115             IDictionary<string, object> expectedMetadata = null;\r
 116 \r
 117             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 118             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 119 \r
 120             ICompositionElement expectedOrigin = new MockOrigin();\r
 121 \r
 122             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 123                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 124                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 125                 expectedMetadata.AsLazy(), expectedOrigin);\r
 126             Assert.IsNotNull(partDefinition);\r
 127 \r
 128             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 129             Assert.IsNotNull(definition);\r
 130             Assert.IsNotNull(definition.Metadata);\r
 131             Assert.AreEqual(0, definition.Metadata.Count);\r
 132         }\r
 133 \r
 134 \r
 135         [TestMethod]\r
 136         public void CreatePartDefinition_NullExportsAllowed()\r
 137         {\r
 138             Type expectedType = typeof(TestPart);\r
 139             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 140 \r
 141             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 142             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 143             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 144 \r
 145             ICompositionElement expectedOrigin = new MockOrigin();\r
 146 \r
 147             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 148                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 149                 null,\r
 150                 expectedMetadata.AsLazy(), expectedOrigin);\r
 151             Assert.IsNotNull(partDefinition);\r
 152 \r
 153             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 154             Assert.IsNotNull(definition);\r
 155             Assert.IsNotNull(definition.ExportDefinitions);\r
 156             Assert.AreEqual(0, definition.ExportDefinitions.Count());\r
 157         }\r
 158 \r
 159         [TestMethod]\r
 160         public void CreatePartDefinition_EvaluatedNullExportsAllowed()\r
 161         {\r
 162             Type expectedType = typeof(TestPart);\r
 163             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 164 \r
 165             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 166             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 167             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 168 \r
 169             ICompositionElement expectedOrigin = new MockOrigin();\r
 170 \r
 171             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 172                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 173                 new Lazy<IEnumerable<ExportDefinition>>(() => null),\r
 174                 expectedMetadata.AsLazy(), expectedOrigin);\r
 175             Assert.IsNotNull(partDefinition);\r
 176 \r
 177             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 178             Assert.IsNotNull(definition);\r
 179             Assert.IsNotNull(definition.ExportDefinitions);\r
 180             Assert.AreEqual(0, definition.ExportDefinitions.Count());\r
 181         }\r
 182 \r
 183         [TestMethod]\r
 184         public void CreatePartDefinition_ExportsMustBeOfRightType()\r
 185         {\r
 186             Type expectedType = typeof(TestPart);\r
 187             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 188 \r
 189             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 190             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 191             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 192 \r
 193             ICompositionElement expectedOrigin = new MockOrigin();\r
 194 \r
 195             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 196                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 197                 new Lazy<IEnumerable<ExportDefinition>>(() => CreateInvalidExports()),\r
 198                 expectedMetadata.AsLazy(), expectedOrigin);\r
 199             Assert.IsNotNull(partDefinition);\r
 200 \r
 201             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 202             Assert.IsNotNull(definition);\r
 203 \r
 204             ExceptionAssert.Throws<InvalidOperationException>(() =>\r
 205             {\r
 206                 definition.ExportDefinitions.Count();\r
 207             });\r
 208         }\r
 209 \r
 210         [TestMethod]\r
 211         public void CreatePartDefinition_NullImportsAllowed()\r
 212         {\r
 213             Type expectedType = typeof(TestPart);\r
 214             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 215 \r
 216             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 217             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 218             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 219 \r
 220             ICompositionElement expectedOrigin = new MockOrigin();\r
 221 \r
 222             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 223                 null,\r
 224                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 225                 expectedMetadata.AsLazy(), expectedOrigin);\r
 226             Assert.IsNotNull(partDefinition);\r
 227 \r
 228             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 229             Assert.IsNotNull(definition);\r
 230             Assert.IsNotNull(definition.ImportDefinitions);\r
 231             Assert.AreEqual(0, definition.ImportDefinitions.Count());\r
 232         }\r
 233 \r
 234         [TestMethod]\r
 235         public void CreatePartDefinition_EvaluatedNullImportsAllowed()\r
 236         {\r
 237             Type expectedType = typeof(TestPart);\r
 238             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 239 \r
 240             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 241             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 242             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 243 \r
 244             ICompositionElement expectedOrigin = new MockOrigin();\r
 245 \r
 246             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 247                 new Lazy<IEnumerable<ImportDefinition>>(() => null),\r
 248                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 249                 expectedMetadata.AsLazy(), expectedOrigin);\r
 250             Assert.IsNotNull(partDefinition);\r
 251 \r
 252             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 253             Assert.IsNotNull(definition);\r
 254             Assert.IsNotNull(definition.ImportDefinitions);\r
 255             Assert.AreEqual(0, definition.ImportDefinitions.Count());\r
 256         }\r
 257 \r
 258         [TestMethod]\r
 259         public void CreatePartDefinition_ImportsMustBeOfRightType()\r
 260         {\r
 261             Type expectedType = typeof(TestPart);\r
 262             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 263 \r
 264             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 265             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 266             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 267 \r
 268             ICompositionElement expectedOrigin = new MockOrigin();\r
 269 \r
 270             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 271                 new Lazy<IEnumerable<ImportDefinition>>(() => CreateInvalidImports()),\r
 272                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 273                 expectedMetadata.AsLazy(), expectedOrigin);\r
 274             Assert.IsNotNull(partDefinition);\r
 275 \r
 276             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 277             Assert.IsNotNull(definition);\r
 278             ExceptionAssert.Throws<InvalidOperationException>(() =>\r
 279             {\r
 280                 definition.ImportDefinitions.Count();\r
 281             });\r
 282 \r
 283         }\r
 284 \r
 285         [TestMethod]\r
 286         public void CreatePartDefinition_NullTypeNotAllowed()\r
 287         {\r
 288             Type expectedType = typeof(TestPart);\r
 289             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 290             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 291             expectedMetadata["Key1"] = 1;\r
 292             expectedMetadata["Key2"] = "Value2";\r
 293 \r
 294             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 295             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 296 \r
 297             ICompositionElement expectedOrigin = new MockOrigin();\r
 298 \r
 299             ExceptionAssert.ThrowsArgument<ArgumentNullException>("partType", () =>\r
 300             {\r
 301                 ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(null, false,\r
 302                     new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 303                     new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 304                     expectedMetadata.AsLazy(), expectedOrigin);\r
 305             });\r
 306         }\r
 307 \r
 308 \r
 309         [TestMethod]\r
 310         public void CreatePartDefinition_NullEvaluatedTypeNotAllowed()\r
 311         {\r
 312             Type expectedType = typeof(TestPart);\r
 313             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 314 \r
 315             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 316             expectedMetadata["Key1"] = 1;\r
 317             expectedMetadata["Key2"] = "Value2";\r
 318 \r
 319             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 320             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 321 \r
 322             ICompositionElement expectedOrigin = new MockOrigin();\r
 323 \r
 324             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(new Lazy<Type>(() => null), false,\r
 325                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 326                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 327                 expectedMetadata.AsLazy(), expectedOrigin);\r
 328 \r
 329             ReflectionComposablePartDefinition definition = partDefinition as ReflectionComposablePartDefinition;\r
 330             Assert.IsNotNull(definition);\r
 331 \r
 332             ExceptionAssert.Throws<InvalidOperationException>(() =>\r
 333             {\r
 334                 definition.GetPartType();\r
 335             });\r
 336         }\r
 337 \r
 338         [TestMethod]\r
 339         public void GetPartType()\r
 340         {\r
 341             Type expectedType = typeof(TestPart);\r
 342             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 343             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 344             expectedMetadata["Key1"] = 1;\r
 345             expectedMetadata["Key2"] = "Value2";\r
 346 \r
 347             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 348             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 349 \r
 350             ICompositionElement expectedOrigin = new MockOrigin();\r
 351 \r
 352             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 353                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 354                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 355                 expectedMetadata.AsLazy(), expectedOrigin);\r
 356             Assert.IsNotNull(partDefinition);\r
 357 \r
 358             Lazy<Type> lazyPartType = ReflectionModelServices.GetPartType(partDefinition);\r
 359             Assert.AreEqual(expectedLazyType, lazyPartType);\r
 360         }\r
 361 \r
 362         [TestMethod]\r
 363         public void GetPartType_NullAsPart_ShouldThrowArgumentNull()\r
 364         {\r
 365             ExceptionAssert.ThrowsArgument<ArgumentNullException>("partDefinition", () =>\r
 366             {\r
 367                 ReflectionModelServices.GetPartType(null);\r
 368             });\r
 369         }\r
 370 \r
 371         [TestMethod]\r
 372         public void GetPartType_InvalidPart_ShouldThrowArgument()\r
 373         {\r
 374             ExceptionAssert.ThrowsArgument<ArgumentException>("partDefinition", () =>\r
 375             {\r
 376                 ReflectionModelServices.GetPartType(new InvalidPartDefinition());\r
 377             });\r
 378         }\r
 379 \r
 380 \r
 381         [TestMethod]\r
 382         public void IsDisposalRequired_ForNonDisposable()\r
 383         {\r
 384             Type expectedType = typeof(TestPart);\r
 385             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 386             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 387             expectedMetadata["Key1"] = 1;\r
 388             expectedMetadata["Key2"] = "Value2";\r
 389 \r
 390             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 391             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 392 \r
 393             ICompositionElement expectedOrigin = new MockOrigin();\r
 394 \r
 395             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, false,\r
 396                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 397                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 398                 expectedMetadata.AsLazy(), expectedOrigin);\r
 399             Assert.IsNotNull(partDefinition);\r
 400 \r
 401             bool isDisposalRequired = ReflectionModelServices.IsDisposalRequired(partDefinition);\r
 402             Assert.IsFalse(isDisposalRequired);\r
 403         }\r
 404 \r
 405         [TestMethod]\r
 406         public void IsDisposalRequired_ForDisposable()\r
 407         {\r
 408             Type expectedType = typeof(TestPart);\r
 409             Lazy<Type> expectedLazyType = expectedType.AsLazy();\r
 410             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 411             expectedMetadata["Key1"] = 1;\r
 412             expectedMetadata["Key2"] = "Value2";\r
 413 \r
 414             IEnumerable<ImportDefinition> expectedImports = CreateImports(expectedType);\r
 415             IEnumerable<ExportDefinition> expectedExports = CreateExports(expectedType);\r
 416 \r
 417             ICompositionElement expectedOrigin = new MockOrigin();\r
 418 \r
 419             ComposablePartDefinition partDefinition = ReflectionModelServices.CreatePartDefinition(expectedLazyType, true,\r
 420                 new Lazy<IEnumerable<ImportDefinition>>(() => expectedImports),\r
 421                 new Lazy<IEnumerable<ExportDefinition>>(() => expectedExports),\r
 422                 expectedMetadata.AsLazy(), expectedOrigin);\r
 423             Assert.IsNotNull(partDefinition);\r
 424 \r
 425             bool isDisposalRequired = ReflectionModelServices.IsDisposalRequired(partDefinition);\r
 426             Assert.IsTrue(isDisposalRequired);\r
 427         }\r
 428 \r
 429 \r
 430         [TestMethod]\r
 431         public void IsDisposalRequired_NullAsPart_ShouldThrowArgumentNull()\r
 432         {\r
 433             ExceptionAssert.ThrowsArgument<ArgumentNullException>("partDefinition", () =>\r
 434             {\r
 435                 ReflectionModelServices.IsDisposalRequired(null);\r
 436             });\r
 437         }\r
 438 \r
 439         [TestMethod]\r
 440         public void IsDisposalRequired_InvalidPart_ShouldThrowArgument()\r
 441         {\r
 442             ExceptionAssert.ThrowsArgument<ArgumentException>("partDefinition", () =>\r
 443             {\r
 444                 ReflectionModelServices.IsDisposalRequired(new InvalidPartDefinition());\r
 445             });\r
 446         }\r
 447 \r
 448         [TestMethod]\r
 449         public void CreateExportDefinition()\r
 450         {\r
 451             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 452             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 453 \r
 454             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 455             expectedMetadata["Key1"] = 1;\r
 456             expectedMetadata["Key2"] = "Value2";\r
 457 \r
 458             string expectedContractName = "Foo";\r
 459 \r
 460             ICompositionElement expectedOrigin = new MockOrigin();\r
 461 \r
 462             ExportDefinition exportDefinition = ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin);\r
 463             Assert.IsNotNull(exportDefinition);\r
 464             ReflectionMemberExportDefinition definition = exportDefinition as ReflectionMemberExportDefinition;\r
 465             Assert.IsNotNull(definition);\r
 466 \r
 467             Assert.AreEqual(expectedContractName, definition.ContractName);\r
 468             Assert.IsTrue(definition.Metadata.Keys.SequenceEqual(expectedMetadata.Keys));\r
 469             Assert.IsTrue(definition.Metadata.Values.SequenceEqual(expectedMetadata.Values));\r
 470             Assert.AreEqual(expectedOrigin, ((ICompositionElement)definition).Origin);\r
 471             Assert.AreEqual(expectedLazyMember, definition.ExportingLazyMember);\r
 472         }\r
 473 \r
 474         [TestMethod]\r
 475         public void CreateExportDefinition_NullAsContractName_ThrowsNullArgument()\r
 476         {\r
 477             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 478             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 479 \r
 480             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 481             expectedMetadata["Key1"] = 1;\r
 482             expectedMetadata["Key2"] = "Value2";\r
 483 \r
 484 \r
 485             ICompositionElement expectedOrigin = new MockOrigin();\r
 486 \r
 487             ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () =>\r
 488             {\r
 489                 ReflectionModelServices.CreateExportDefinition(expectedLazyMember, null, expectedMetadata.AsLazy(), expectedOrigin);\r
 490             });\r
 491         }\r
 492 \r
 493         public void CreateExportDefinition_NullAsMetadata_Allowed()\r
 494         {\r
 495             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 496             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 497 \r
 498             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 499             expectedMetadata["Key1"] = 1;\r
 500             expectedMetadata["Key2"] = "Value2";\r
 501 \r
 502             string expectedContractName = "Foo";\r
 503             ICompositionElement expectedOrigin = new MockOrigin();\r
 504 \r
 505             ExportDefinition definition = ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin);\r
 506             Assert.IsNotNull(definition.Metadata);\r
 507             Assert.AreEqual(0, definition.Metadata.Count);\r
 508         }\r
 509 \r
 510         [TestMethod]\r
 511         public void CreateExportDefinition_InvalidLazymemberInfo_ShouldThrowArtument()\r
 512         {\r
 513             EventInfo _event = typeof(TestPart).GetEvents().First();\r
 514             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(_event);\r
 515 \r
 516             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 517             expectedMetadata["Key1"] = 1;\r
 518             expectedMetadata["Key2"] = "Value2";\r
 519 \r
 520             string expectedContractName = "Foo";\r
 521 \r
 522             ICompositionElement expectedOrigin = new MockOrigin();\r
 523 \r
 524             ExceptionAssert.ThrowsArgument<ArgumentException>("exportingMember", () =>\r
 525             {\r
 526                 ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin);\r
 527             });\r
 528         }\r
 529 \r
 530         [TestMethod]\r
 531         public void GetExportingMember()\r
 532         {\r
 533             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 534             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 535 \r
 536             IDictionary<string, object> expectedMetadata = new Dictionary<string, object>();\r
 537             expectedMetadata["Key1"] = 1;\r
 538             expectedMetadata["Key2"] = "Value2";\r
 539 \r
 540             string expectedContractName = "Foo";\r
 541 \r
 542             ICompositionElement expectedOrigin = new MockOrigin();\r
 543 \r
 544             ExportDefinition exportDefinition = ReflectionModelServices.CreateExportDefinition(expectedLazyMember, expectedContractName, expectedMetadata.AsLazy(), expectedOrigin);\r
 545             Assert.IsNotNull(exportDefinition);\r
 546 \r
 547             LazyMemberInfo lazyMember = ReflectionModelServices.GetExportingMember(exportDefinition);\r
 548             Assert.AreEqual(expectedLazyMember, lazyMember);\r
 549         }\r
 550 \r
 551         [TestMethod]\r
 552         public void GetExportingMember_NullAsExportDefinition_ShouldThrowArhumentNull()\r
 553         {\r
 554             ExceptionAssert.ThrowsArgument<ArgumentNullException>("exportDefinition", () =>\r
 555             {\r
 556                 ReflectionModelServices.GetExportingMember(null);\r
 557             });\r
 558         }\r
 559 \r
 560         [TestMethod]\r
 561         public void GetExportingMember_InvalidExportDefinition_ShouldThrowArhumentNull()\r
 562         {\r
 563             ExceptionAssert.ThrowsArgument<ArgumentException>("exportDefinition", () =>\r
 564             {\r
 565                 ReflectionModelServices.GetExportingMember(new ExportDefinition("Foo", null));\r
 566             });\r
 567         }\r
 568 \r
 569         [TestMethod]\r
 570         public void CreateImportDefinition_Member()\r
 571         {\r
 572             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 573             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 574 \r
 575             string expectedContractName = "Foo";\r
 576             string expectedRequiredTypeIdentity = "Bar";\r
 577             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 578             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 579             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 580             bool expectedRecomposable = true;\r
 581 \r
 582             ICompositionElement expectedOrigin = new MockOrigin();\r
 583 \r
 584             ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition(\r
 585                 expectedLazyMember,\r
 586                 expectedContractName,\r
 587                 expectedRequiredTypeIdentity,\r
 588                 expectedRequiredMetadata,\r
 589                 expectedCardinality,\r
 590                 expectedRecomposable,\r
 591                 expectedCreationPolicy,\r
 592                 expectedOrigin);\r
 593             Assert.IsNotNull(importDefinition);\r
 594 \r
 595             ReflectionMemberImportDefinition definition = importDefinition as ReflectionMemberImportDefinition;\r
 596             Assert.IsNotNull(definition);\r
 597 \r
 598             Assert.AreEqual(expectedLazyMember, definition.ImportingLazyMember);\r
 599             Assert.AreEqual(definition.ContractName, expectedContractName);\r
 600             Assert.AreEqual(definition.RequiredTypeIdentity, expectedRequiredTypeIdentity);\r
 601             Assert.IsTrue(definition.RequiredMetadata.SequenceEqual(expectedRequiredMetadata));\r
 602             Assert.AreEqual(definition.Cardinality, expectedCardinality);\r
 603             Assert.AreEqual(definition.RequiredCreationPolicy, expectedCreationPolicy);\r
 604             Assert.AreEqual(definition.IsRecomposable, expectedRecomposable);\r
 605             Assert.AreSame(expectedOrigin, ((ICompositionElement)definition).Origin);\r
 606             Assert.IsFalse(definition.IsPrerequisite);\r
 607         }\r
 608 \r
 609         [TestMethod]\r
 610         public void CreateImportDefinition_Member_InvalidMember_ShouldThrowArgument()\r
 611         {\r
 612             MethodInfo method = typeof(TestPart).GetMethods().First();\r
 613             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(method);\r
 614 \r
 615             string expectedContractName = "Foo";\r
 616             string expectedRequiredTypeIdentity = "Bar";\r
 617             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 618             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 619             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 620             bool expectedRecomposable = true;\r
 621 \r
 622             ICompositionElement expectedOrigin = new MockOrigin();\r
 623 \r
 624             ExceptionAssert.ThrowsArgument<ArgumentException>("importingMember", () =>\r
 625             {\r
 626                 ReflectionModelServices.CreateImportDefinition(\r
 627                 expectedLazyMember,\r
 628                 expectedContractName,\r
 629                 expectedRequiredTypeIdentity,\r
 630                 expectedRequiredMetadata,\r
 631                 expectedCardinality,\r
 632                 expectedRecomposable,\r
 633                 expectedCreationPolicy,\r
 634                 expectedOrigin);\r
 635             });\r
 636         }\r
 637 \r
 638         [TestMethod]\r
 639         public void GetImporingMember()\r
 640         {\r
 641             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 642             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 643 \r
 644             string expectedContractName = "Foo";\r
 645             string expectedRequiredTypeIdentity = "Bar";\r
 646             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 647             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 648             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 649             bool expectedRecomposable = true;\r
 650 \r
 651             ICompositionElement expectedOrigin = new MockOrigin();\r
 652 \r
 653             ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition(\r
 654                 expectedLazyMember,\r
 655                 expectedContractName,\r
 656                 expectedRequiredTypeIdentity,\r
 657                 expectedRequiredMetadata,\r
 658                 expectedCardinality,\r
 659                 expectedRecomposable,\r
 660                 expectedCreationPolicy,\r
 661                 expectedOrigin);\r
 662             Assert.IsNotNull(importDefinition);\r
 663 \r
 664             LazyMemberInfo lazyMember = ReflectionModelServices.GetImportingMember(importDefinition);\r
 665             Assert.AreEqual(expectedLazyMember, lazyMember);\r
 666         }\r
 667 \r
 668         [TestMethod]\r
 669         public void GetImporingMember_NullAsImport_ShouldThrowArgumentNull()\r
 670         {\r
 671             ExceptionAssert.ThrowsArgument<ArgumentNullException>("importDefinition", () =>\r
 672             {\r
 673                 ReflectionModelServices.GetImportingMember(null);\r
 674             });\r
 675         }\r
 676 \r
 677         [TestMethod]\r
 678         public void GetImporingMember_InvalidImport_ShouldThrowArgument()\r
 679         {\r
 680             ExceptionAssert.ThrowsArgument<ArgumentException>("importDefinition", () =>\r
 681             {\r
 682                 ReflectionModelServices.GetImportingMember(new ContractBasedImportDefinition("Foo", "Foo", null, ImportCardinality.ZeroOrMore, false, false, CreationPolicy.Any));\r
 683             });\r
 684         }\r
 685 \r
 686 \r
 687 \r
 688         [TestMethod]\r
 689         public void CreateImportDefinition_Parameter()\r
 690         {\r
 691 \r
 692             ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0];\r
 693             Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy();\r
 694 \r
 695             string expectedContractName = "Foo";\r
 696             string expectedRequiredTypeIdentity = "Bar";\r
 697             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 698             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 699             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 700 \r
 701             ICompositionElement expectedOrigin = new MockOrigin();\r
 702 \r
 703             ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition(\r
 704                 expectedLazyParameter,\r
 705                 expectedContractName,\r
 706                 expectedRequiredTypeIdentity,\r
 707                 expectedRequiredMetadata,\r
 708                 expectedCardinality,\r
 709                 expectedCreationPolicy,\r
 710                 expectedOrigin);\r
 711             Assert.IsNotNull(importDefinition);\r
 712 \r
 713             ReflectionParameterImportDefinition definition = importDefinition as ReflectionParameterImportDefinition;\r
 714             Assert.IsNotNull(definition);\r
 715 \r
 716             Assert.AreEqual(expectedLazyParameter, definition.ImportingLazyParameter);\r
 717             Assert.AreEqual(definition.ContractName, expectedContractName);\r
 718             Assert.AreEqual(definition.RequiredTypeIdentity, expectedRequiredTypeIdentity);\r
 719             Assert.IsTrue(definition.RequiredMetadata.SequenceEqual(expectedRequiredMetadata));\r
 720             Assert.AreEqual(definition.Cardinality, expectedCardinality);\r
 721             Assert.AreEqual(definition.RequiredCreationPolicy, expectedCreationPolicy);\r
 722             Assert.IsFalse(definition.IsRecomposable);\r
 723             Assert.AreSame(expectedOrigin, ((ICompositionElement)definition).Origin);\r
 724             Assert.IsTrue(definition.IsPrerequisite);\r
 725         }\r
 726 \r
 727         [TestMethod]\r
 728         public void CreateImportDefinition_Parameter_NullAsParamater_ShouldThrowArgumentNull()\r
 729         {\r
 730             ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0];\r
 731             Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy();\r
 732 \r
 733             string expectedContractName = "Foo";\r
 734             string expectedRequiredTypeIdentity = "Bar";\r
 735             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 736             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 737             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 738 \r
 739             ICompositionElement expectedOrigin = new MockOrigin();\r
 740 \r
 741             ExceptionAssert.ThrowsArgument<ArgumentNullException>("parameter", () =>\r
 742             {\r
 743                 ReflectionModelServices.CreateImportDefinition(\r
 744                                 null,\r
 745                                 expectedContractName,\r
 746                                 expectedRequiredTypeIdentity,\r
 747                                 expectedRequiredMetadata,\r
 748                                 expectedCardinality,\r
 749                                 expectedCreationPolicy,\r
 750                                 expectedOrigin);\r
 751             });\r
 752         }\r
 753 \r
 754         [TestMethod]\r
 755         public void GetImportingParameter()\r
 756         {\r
 757             ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0];\r
 758             Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy();\r
 759 \r
 760             string expectedContractName = "Foo";\r
 761             string expectedRequiredTypeIdentity = "Bar";\r
 762             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 763             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 764             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 765 \r
 766             ICompositionElement expectedOrigin = new MockOrigin();\r
 767             ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition(\r
 768                 expectedLazyParameter,\r
 769                 expectedContractName,\r
 770                 expectedRequiredTypeIdentity,\r
 771                 expectedRequiredMetadata,\r
 772                 expectedCardinality,\r
 773                 expectedCreationPolicy,\r
 774                 expectedOrigin);\r
 775             Assert.IsNotNull(importDefinition);\r
 776 \r
 777             Lazy<ParameterInfo> lazyParameter = ReflectionModelServices.GetImportingParameter(importDefinition);\r
 778             Assert.AreEqual(expectedLazyParameter, lazyParameter);\r
 779         }\r
 780 \r
 781         [TestMethod]\r
 782         public void GetImportingParameter_NullAsImport_ShouldThrowArgumentNull()\r
 783         {\r
 784             ExceptionAssert.ThrowsArgument<ArgumentNullException>("importDefinition", () =>\r
 785             {\r
 786                 ReflectionModelServices.GetImportingParameter(null);\r
 787             });\r
 788         }\r
 789 \r
 790         [TestMethod]\r
 791         public void GetImportingParameter_InvalidImport_ShouldThrowArgument()\r
 792         {\r
 793             ExceptionAssert.ThrowsArgument<ArgumentException>("importDefinition", () =>\r
 794             {\r
 795                 ReflectionModelServices.GetImportingParameter(new ContractBasedImportDefinition("Foo", "Foo", null, ImportCardinality.ZeroOrMore, false, false, CreationPolicy.Any));\r
 796             });\r
 797         }\r
 798 \r
 799         [TestMethod]\r
 800         public void IsImportingParameter_OnParameterImport()\r
 801         {\r
 802             ParameterInfo parameter = typeof(TestPart).GetConstructor(new Type[] { typeof(int) }).GetParameters()[0];\r
 803             Lazy<ParameterInfo> expectedLazyParameter = parameter.AsLazy();\r
 804 \r
 805             string expectedContractName = "Foo";\r
 806             string expectedRequiredTypeIdentity = "Bar";\r
 807             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 808             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 809             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 810 \r
 811             ICompositionElement expectedOrigin = new MockOrigin();\r
 812             ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition(\r
 813                 expectedLazyParameter,\r
 814                 expectedContractName,\r
 815                 expectedRequiredTypeIdentity,\r
 816                 expectedRequiredMetadata,\r
 817                 expectedCardinality,\r
 818                 expectedCreationPolicy,\r
 819                 expectedOrigin);\r
 820             Assert.IsNotNull(importDefinition);\r
 821 \r
 822             Assert.IsTrue(ReflectionModelServices.IsImportingParameter(importDefinition));\r
 823         }\r
 824 \r
 825         [TestMethod]\r
 826         public void IsImportingParameter_OnMemberImport()\r
 827         {\r
 828             PropertyInfo property = typeof(TestPart).GetProperties().First();\r
 829             LazyMemberInfo expectedLazyMember = new LazyMemberInfo(property);\r
 830 \r
 831             string expectedContractName = "Foo";\r
 832             string expectedRequiredTypeIdentity = "Bar";\r
 833             KeyValuePair<string, Type>[] expectedRequiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) };\r
 834             ImportCardinality expectedCardinality = ImportCardinality.ExactlyOne;\r
 835             CreationPolicy expectedCreationPolicy = CreationPolicy.NonShared;\r
 836             bool expectedRecomposable = true;\r
 837 \r
 838             ICompositionElement expectedOrigin = new MockOrigin();\r
 839 \r
 840             ImportDefinition importDefinition = ReflectionModelServices.CreateImportDefinition(\r
 841                 expectedLazyMember,\r
 842                 expectedContractName,\r
 843                 expectedRequiredTypeIdentity,\r
 844                 expectedRequiredMetadata,\r
 845                 expectedCardinality,\r
 846                 expectedRecomposable,\r
 847                 expectedCreationPolicy,\r
 848                 expectedOrigin);\r
 849             Assert.IsNotNull(importDefinition);\r
 850 \r
 851             Assert.IsFalse(ReflectionModelServices.IsImportingParameter(importDefinition));\r
 852         }\r
 853 \r
 854         [TestMethod]\r
 855         public void IsImportingParameter_NullAsImport_ShouldThrowArgumentNull()\r
 856         {\r
 857             ExceptionAssert.ThrowsArgument<ArgumentNullException>("importDefinition", () =>\r
 858             {\r
 859                 ReflectionModelServices.IsImportingParameter(null);\r
 860             });\r
 861         }\r
 862 \r
 863         [TestMethod]\r
 864         public void IsImportingParameter_InvalidImport_ShouldThrowArgument()\r
 865         {\r
 866             ExceptionAssert.ThrowsArgument<ArgumentException>("importDefinition", () =>\r
 867             {\r
 868                 ReflectionModelServices.IsImportingParameter(new ContractBasedImportDefinition("Foo", "Foo", null, ImportCardinality.ZeroOrMore, false, false, CreationPolicy.Any));\r
 869             });\r
 870         }\r
 871 \r
 872         [TestMethod]\r
 873         public void IsExportFactoryImportDefinition_NullImport_ShouldThrowArgumentNull()\r
 874         {\r
 875             ExceptionAssert.ThrowsArgumentNull("importDefinition", () =>\r
 876                 ReflectionModelServices.IsExportFactoryImportDefinition(null));\r
 877         }\r
 878         \r
 879         [TestMethod]\r
 880         public void IsExportFactoryImportDefinition_InvalidImport_ShouldThrowArgument()\r
 881         {\r
 882             ExceptionAssert.ThrowsArgument("importDefinition", () =>\r
 883                 ReflectionModelServices.IsExportFactoryImportDefinition(CreateInvalidImport()));\r
 884         }\r
 885         \r
 886         [TestMethod]\r
 887         public void IsExportFactoryImportDefinition_NonPartCreatorImport_ShouldReturnFalse()\r
 888         {\r
 889             var import = ReflectionModelServices.CreateImportDefinition(\r
 890                 new LazyMemberInfo(MemberTypes.Field, () => new MemberInfo[] { typeof(ReflectionModelServicesTests) }), // bogus member\r
 891                 "Foo",\r
 892                 "Foo",\r
 893                 Enumerable.Empty<KeyValuePair<string, Type>>(),\r
 894                 ImportCardinality.ZeroOrMore,\r
 895                 false,\r
 896                 CreationPolicy.Any,\r
 897                 null);\r
 898 \r
 899             Assert.IsFalse(ReflectionModelServices.IsExportFactoryImportDefinition(import));\r
 900         }\r
 901 \r
 902         [TestMethod]\r
 903         public void IsExportFactoryImportDefinition_PartCreatorImport_ShouldReturnTrue()\r
 904         {\r
 905             var import = ReflectionModelServices.CreateImportDefinition(\r
 906                 new LazyMemberInfo(MemberTypes.Field, () => new MemberInfo[] { typeof(ReflectionModelServicesTests) }), // bogus member\r
 907                 "Foo",\r
 908                 "Foo",\r
 909                 Enumerable.Empty<KeyValuePair<string, Type>>(),\r
 910                 ImportCardinality.ZeroOrMore,\r
 911                 false,\r
 912                 CreationPolicy.Any,\r
 913                 true, //isPartCreator\r
 914                 null);\r
 915 \r
 916             Assert.IsTrue(ReflectionModelServices.IsExportFactoryImportDefinition(import));\r
 917         }\r
 918 \r
 919         [TestMethod]\r
 920         public void GetPartCreatorProductImportDefinition_NullImport_ShouldThrowArgumentNull()\r
 921         {\r
 922             ExceptionAssert.ThrowsArgumentNull("importDefinition", () =>\r
 923                 ReflectionModelServices.GetPartCreatorProductImportDefinition(null));\r
 924         }\r
 925 \r
 926         [TestMethod]\r
 927         public void GetPartCreatorProductImportDefinition_InvalidImport_ShouldThrowArgument()\r
 928         {\r
 929             ExceptionAssert.ThrowsArgument("importDefinition", () =>\r
 930                 ReflectionModelServices.GetPartCreatorProductImportDefinition(CreateInvalidImport()));\r
 931         }\r
 932 \r
 933         [TestMethod]\r
 934         public void GetPartCreatorProductImportDefinition_()\r
 935         {\r
 936 \r
 937         }\r
 938 \r
 939         [TestMethod]\r
 940         public void GetPartCreatorProductImportDefinition_PartCreatorImport_()\r
 941         {\r
 942             LazyMemberInfo bogusMember = new LazyMemberInfo(MemberTypes.Field, () => new MemberInfo[] { typeof(ReflectionModelServicesTests) });\r
 943             var import = ReflectionModelServices.CreateImportDefinition(\r
 944                 bogusMember,\r
 945                 "Foo",\r
 946                 "Foo",\r
 947                 Enumerable.Empty<KeyValuePair<string, Type>>(),\r
 948                 ImportCardinality.ZeroOrMore,\r
 949                 false,\r
 950                 CreationPolicy.Any,\r
 951                 true, //isPartCreator\r
 952                 null);\r
 953 \r
 954             var productImport = ReflectionModelServices.GetPartCreatorProductImportDefinition(import);\r
 955 \r
 956             var import2 = ReflectionModelServices.CreateImportDefinition(\r
 957                 bogusMember,\r
 958                 productImport.ContractName,\r
 959                 productImport.RequiredTypeIdentity,\r
 960                 productImport.RequiredMetadata,\r
 961                 productImport.Cardinality,\r
 962                 productImport.IsRecomposable,\r
 963                 productImport.RequiredCreationPolicy,\r
 964                 true, //isPartCreator\r
 965                 null);\r
 966 \r
 967             Assert.AreEqual(import.ContractName, import2.ContractName);\r
 968             Assert.AreEqual(import.Cardinality, import2.Cardinality);\r
 969             Assert.AreEqual(import.IsRecomposable, import2.IsRecomposable);\r
 970             Assert.AreEqual(import.RequiredCreationPolicy, import2.RequiredCreationPolicy);\r
 971             Assert.AreEqual(import.RequiredTypeIdentity, import2.RequiredTypeIdentity);\r
 972             EnumerableAssert.AreEqual(import.RequiredMetadata, import2.RequiredMetadata);\r
 973         }\r
 974 \r
 975         private static IEnumerable<ImportDefinition> CreateInvalidImports()\r
 976         {\r
 977             yield return new ContractBasedImportDefinition("Foo", "Foo", null, ImportCardinality.ZeroOrMore, false, false, CreationPolicy.Any);\r
 978         }\r
 979 \r
 980         private static ImportDefinition CreateInvalidImport()\r
 981         {\r
 982             return new ContractBasedImportDefinition("Foo", "Foo", null, ImportCardinality.ZeroOrMore, false, false, CreationPolicy.Any);\r
 983         }\r
 984 \r
 985         private static IEnumerable<ExportDefinition> CreateInvalidExports()\r
 986         {\r
 987             yield return new ExportDefinition("Foo", null);\r
 988         }\r
 989 \r
 990 \r
 991         class InvalidPartDefinition : ComposablePartDefinition\r
 992         {\r
 993             public override ComposablePart CreatePart()\r
 994             {\r
 995                 throw new NotImplementedException();\r
 996             }\r
 997 \r
 998             public override IEnumerable<ExportDefinition> ExportDefinitions\r
 999             {\r
1000                 get { throw new NotImplementedException(); }\r
1001             }\r
1002 \r
1003             public override IEnumerable<ImportDefinition> ImportDefinitions\r
1004             {\r
1005                 get { throw new NotImplementedException(); }\r
1006             }\r
1007         }\r
1008 \r
1009         private static List<ImportDefinition> CreateImports(Type type)\r
1010         {\r
1011             List<ImportDefinition> imports = new List<ImportDefinition>();\r
1012             foreach (PropertyInfo property in type.GetProperties())\r
1013             {\r
1014                 imports.Add(new ReflectionMemberImportDefinition(new LazyMemberInfo(property), "Contract", (string)null, new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Key1", typeof(string)), new KeyValuePair<string, Type>("Key2", typeof(int)) }, ImportCardinality.ZeroOrOne, true, CreationPolicy.Any, new TypeOrigin(type)));\r
1015             }\r
1016 \r
1017             return imports;\r
1018         }\r
1019 \r
1020         private static List<ExportDefinition> CreateExports(Type type)\r
1021         {\r
1022             List<ExportDefinition> exports = new List<ExportDefinition>();\r
1023             foreach (PropertyInfo property in type.GetProperties())\r
1024             {\r
1025                 exports.Add(ReflectionModelServices.CreateExportDefinition(new LazyMemberInfo(property), "Contract", new Lazy<IDictionary<string, object>>(() => null), new TypeOrigin(type)));\r
1026             }\r
1027 \r
1028             return exports;\r
1029         }\r
1030 \r
1031         public class TestPart\r
1032         {\r
1033             public TestPart(int arg1)\r
1034             {\r
1035             }\r
1036 \r
1037             public int field1;\r
1038             public string field2;\r
1039             public int Property1 { get; set; }\r
1040             public string Property2\r
1041             {\r
1042                 get { return null; }\r
1043                 set\r
1044                 {\r
1045                     this.Event.Invoke(this, null);\r
1046                 }\r
1047             }\r
1048             public event EventHandler Event;\r
1049         }\r
1050 \r
1051         private class TypeOrigin : ICompositionElement\r
1052         {\r
1053             private readonly Type _type;\r
1054             private readonly ICompositionElement _orgin;\r
1055 \r
1056             public TypeOrigin(Type type)\r
1057                 : this(type, null)\r
1058             {\r
1059             }\r
1060 \r
1061             public TypeOrigin(Type type, ICompositionElement origin)\r
1062             {\r
1063                 this._type = type;\r
1064                 this._orgin = origin;\r
1065             }\r
1066 \r
1067             public string DisplayName\r
1068             {\r
1069                 get\r
1070                 {\r
1071                     return this._type.GetDisplayName();\r
1072                 }\r
1073             }\r
1074 \r
1075             public ICompositionElement Origin\r
1076             {\r
1077                 get\r
1078                 {\r
1079                     return this._orgin;\r
1080                 }\r
1081             }\r
1082         }\r
1083 \r
1084         private class MockOrigin : ICompositionElement\r
1085         {\r
1086             public string DisplayName\r
1087             {\r
1088                 get { throw new NotImplementedException(); }\r
1089             }\r
1090 \r
1091             public ICompositionElement Origin\r
1092             {\r
1093                 get { throw new NotImplementedException(); }\r
1094             }\r
1095         }\r
1096 \r
1097     }\r
1098 }