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

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