mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/Integration/DiscoveryTests.cs

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Collections.Generic;\r
   6 using System.ComponentModel.Composition;\r
   7 using System.ComponentModel.Composition.AttributedModel;\r
   8 using System.ComponentModel.Composition.Primitives;\r
   9 using System.ComponentModel.Composition.Factories;\r
  10 using System.ComponentModel.Composition.Hosting;\r
  11 using System.ComponentModel.Composition.UnitTesting;\r
  12 using System.Linq;\r
  13 using System.Reflection;\r
  14 using System.UnitTesting;\r
  15 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  16 \r
  17 namespace Tests.Integration\r
  18 {\r
  19     [TestClass]\r
  20     public class DiscoveryTests\r
  21     {\r
  22         public abstract class AbstractClassWithExports\r
  23         {\r
  24             [Export("StaticExport")]\r
  25             public static string StaticExport { get { return "ExportedValue"; } }\r
  26 \r
  27             [Export("InstanceExport")]\r
  28             public string InstanceExport { get { return "InstanceExportedValue"; } }\r
  29         }\r
  30 \r
  31         [TestMethod]\r
  32         public void Export_StaticOnAbstractClass_ShouldExist()\r
  33         {\r
  34             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(AbstractClassWithExports));\r
  35 \r
  36             Assert.IsTrue(container.IsPresent("StaticExport"));\r
  37             Assert.IsFalse(container.IsPresent("InstanceExport"));\r
  38         }\r
  39 \r
  40         public class ClassWithStaticImport\r
  41         {\r
  42             [Import("StaticImport")]\r
  43             public static string MyImport\r
  44             {\r
  45                 get; set;\r
  46             }\r
  47         }\r
  48 \r
  49         [TestMethod]\r
  50         public void Import_StaticImport_ShouldNotBeSet()\r
  51         {\r
  52             var container = ContainerFactory.Create();\r
  53             container.AddAndComposeExportedValue("StaticImport", "String that shouldn't be imported");\r
  54 \r
  55             var importer = new ClassWithStaticImport();\r
  56 \r
  57             container.SatisfyImportsOnce(importer);\r
  58 \r
  59             Assert.IsNull(ClassWithStaticImport.MyImport, "Static import should not have been set!");\r
  60         }\r
  61 \r
  62 #if !SILVERLIGHT\r
  63 // private imports don't work on SILVERLIGHT\r
  64         [Export]\r
  65         public class BaseWithNonPublicImportAndExport\r
  66         {\r
  67             [Import("BasePrivateImport")]\r
  68             private string _basePrivateImport = null;\r
  69 \r
  70             public string BasePrivateImport { get { return this._basePrivateImport; } }\r
  71         }\r
  72 \r
  73         [Export]\r
  74         public class DerivedBaseWithNonPublicImportAndExport : BaseWithNonPublicImportAndExport\r
  75         {\r
  76 \r
  77         }\r
  78 \r
  79         [TestMethod]\r
  80         public void Import_PrivateOnClass_ShouldSetImport()\r
  81         {\r
  82             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(BaseWithNonPublicImportAndExport));\r
  83             container.AddAndComposeExportedValue("BasePrivateImport", "Imported String");\r
  84 \r
  85             var importer = container.GetExportedValue<BaseWithNonPublicImportAndExport>();\r
  86             Assert.AreEqual("Imported String", importer.BasePrivateImport);\r
  87         }\r
  88 \r
  89 \r
  90         [TestMethod]\r
  91         public void Import_PrivateOnBase_ShouldSetImport()\r
  92         {\r
  93             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(DerivedBaseWithNonPublicImportAndExport));\r
  94             container.AddAndComposeExportedValue("BasePrivateImport", "Imported String");\r
  95 \r
  96             var importer = container.GetExportedValue<DerivedBaseWithNonPublicImportAndExport>();\r
  97             Assert.AreEqual("Imported String", importer.BasePrivateImport);\r
  98         }\r
  99 #endif // !SILVERLIGHT\r
 100 \r
 101         public interface InterfaceWithImport\r
 102         {\r
 103             [Import("InterfaceImport")]\r
 104             int MyImport { get; set; }\r
 105         }\r
 106 \r
 107         public interface InterfaceWithExport\r
 108         {\r
 109             [Export("InterfaceExport")]\r
 110             int MyExport { get; set; }\r
 111         }\r
 112 \r
 113         [TestMethod]\r
 114         public void AttributesOnInterface_ShouldNotBeConsiderAPart()\r
 115         {\r
 116             var catalog = CatalogFactory.CreateAttributed(\r
 117                 typeof(InterfaceWithImport),\r
 118                 typeof(InterfaceWithExport));\r
 119 \r
 120             Assert.AreEqual(0, catalog.Parts.Count());\r
 121         }\r
 122 \r
 123         [Export]\r
 124         public class ClassWithInterfaceInheritedImport : InterfaceWithImport\r
 125         {\r
 126             public int MyImport { get; set; }\r
 127         }\r
 128 \r
 129         [TestMethod]\r
 130         public void Import_InheritImportFromInterface_ShouldExposeImport()\r
 131         {\r
 132             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 133                 typeof(ClassWithInterfaceInheritedImport));\r
 134 \r
 135             container.AddAndComposeExportedValue("InterfaceImport", 42);\r
 136 \r
 137             var importer = container.GetExportedValue<ClassWithInterfaceInheritedImport>();\r
 138 \r
 139             Assert.IsTrue(importer.MyImport == default(int), "Imports declared on interfaces should not be discovered");\r
 140         }\r
 141 \r
 142         public class ClassWithInterfaceInheritedExport : InterfaceWithExport\r
 143         {\r
 144             public ClassWithInterfaceInheritedExport()\r
 145             {\r
 146                 MyExport = 42;\r
 147             }\r
 148 \r
 149             public int MyExport { get; set; }\r
 150         }\r
 151 \r
 152         [TestMethod]\r
 153         public void Import_InheritExportFromInterface_ShouldNotExposeExport()\r
 154         {\r
 155             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 156                 typeof(ClassWithInterfaceInheritedExport));\r
 157 \r
 158             Assert.IsFalse(container.IsPresent("InterfaceExport"), "Export defined on interface should not be discovered!");\r
 159         }\r
 160 \r
 161         public interface IFoo { }\r
 162 \r
 163         [InheritedExport]\r
 164         public abstract class BaseWithVirtualExport\r
 165         {\r
 166             [Export]\r
 167             public virtual IFoo MyProp { get; set; }\r
 168         }\r
 169 \r
 170         [InheritedExport(typeof(BaseWithVirtualExport))]\r
 171         public class DerivedWithOverrideExport : BaseWithVirtualExport\r
 172         {\r
 173             [Export]\r
 174             public override IFoo MyProp { get; set; }\r
 175         }\r
 176 \r
 177         [TestMethod]\r
 178         public void Export_BaseAndDerivedShouldAmountInTwoExports()\r
 179         {\r
 180             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 181                 typeof(BaseWithVirtualExport),\r
 182                 typeof(DerivedWithOverrideExport));\r
 183 \r
 184             var exports1 = container.GetExportedValues<BaseWithVirtualExport>();\r
 185             Assert.AreEqual(1, exports1.Count());\r
 186 \r
 187             var exports2 = container.GetExportedValues<IFoo>();\r
 188             Assert.AreEqual(1, exports2.Count());\r
 189         }\r
 190 \r
 191         public interface IDocument { }\r
 192 \r
 193         [Export(typeof(IDocument))]\r
 194         [ExportMetadata("Name", "TextDocument")]\r
 195         public class TextDocument : IDocument\r
 196         {\r
 197         }\r
 198 \r
 199         [Export(typeof(IDocument))]\r
 200         [ExportMetadata("Name", "XmlDocument")]\r
 201         public class XmlDocument : TextDocument\r
 202         {\r
 203         }\r
 204 \r
 205         [TestMethod]\r
 206         public void Export_ExportingSameContractInDerived_ShouldResultInHidingBaseExport()\r
 207         {\r
 208             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 209                 typeof(IDocument),\r
 210                 typeof(XmlDocument));\r
 211 \r
 212             var export = container.GetExport<IDocument, IDictionary<string, object>>();\r
 213 \r
 214             Assert.AreEqual("XmlDocument", export.Metadata["Name"]);\r
 215         }\r
 216 \r
 217         [TestMethod]\r
 218         public void Export_ExportingBaseAndDerivedSameContract_ShouldResultInOnlyTwoExports()\r
 219         {\r
 220             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 221                 typeof(IDocument),\r
 222                 typeof(TextDocument),\r
 223                 typeof(XmlDocument));\r
 224 \r
 225             var exports = container.GetExports<IDocument, IDictionary<string, object>>();\r
 226 \r
 227             Assert.AreEqual(2, exports.Count());\r
 228             Assert.AreEqual("TextDocument", exports.ElementAt(0).Metadata["Name"]);\r
 229             Assert.IsInstanceOfType(exports.ElementAt(0).Value, typeof(TextDocument));\r
 230             \r
 231             Assert.AreEqual("XmlDocument", exports.ElementAt(1).Metadata["Name"]);\r
 232             Assert.IsInstanceOfType(exports.ElementAt(1).Value, typeof(XmlDocument));\r
 233         }\r
 234 \r
 235         public interface IObjectSerializer { }\r
 236 \r
 237         [Export(typeof(IDocument))]\r
 238         [Export(typeof(IObjectSerializer))]\r
 239         [ExportMetadata("Name", "XamlDocument")]\r
 240         public class XamlDocument : XmlDocument, IObjectSerializer\r
 241         {\r
 242         }\r
 243 \r
 244         [TestMethod]\r
 245         public void Export_ExportingSameContractInDerivedAndNewContract_ShouldResultInHidingBaseAndExportingNewContract()\r
 246         {\r
 247             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 248                 typeof(XamlDocument));\r
 249 \r
 250             var export = container.GetExport<IDocument, IDictionary<string, object>>();\r
 251 \r
 252             Assert.AreEqual("XamlDocument", export.Metadata["Name"]);\r
 253 \r
 254             var export2 = container.GetExport<IObjectSerializer, IDictionary<string, object>>();\r
 255 \r
 256             Assert.AreEqual("XamlDocument", export2.Metadata["Name"]);\r
 257         }\r
 258 \r
 259 \r
 260         [Export(typeof(IDocument))]\r
 261         [ExportMetadata("Name", "WPFDocument")]\r
 262         public class WPFDocument : XamlDocument\r
 263         {\r
 264         }\r
 265 \r
 266         [TestMethod]\r
 267         public void Export_ExportingSameContractInDerivedAndAnotherContractInBase_ShouldResultInHidingOneBaseAndInheritingNewContract()\r
 268         {\r
 269             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 270                 typeof(WPFDocument));\r
 271 \r
 272             var export = container.GetExport<IDocument, IDictionary<string, object>>();\r
 273 \r
 274             Assert.AreEqual("WPFDocument", export.Metadata["Name"]);\r
 275 \r
 276             var export2 = container.GetExportedValueOrDefault<IObjectSerializer>();\r
 277 \r
 278             Assert.IsNull(export2, "IObjectSerializer export should not have been inherited");\r
 279         }\r
 280        \r
 281         [InheritedExport]\r
 282         public abstract class Plugin\r
 283         {\r
 284             public virtual string GetLocation()\r
 285             {\r
 286                 return "NoWhere";\r
 287             }\r
 288 \r
 289             public virtual int Version\r
 290             {\r
 291                 get\r
 292                 {\r
 293                     return 0;\r
 294                 }\r
 295             }\r
 296         }\r
 297 \r
 298         private void VerifyValidPlugin(CompositionContainer container, int version, string location)\r
 299         {\r
 300             var plugins = container.GetExports<Plugin>();\r
 301             Assert.AreEqual(1, plugins.Count());\r
 302 \r
 303             var plugin = plugins.Single().Value;\r
 304 \r
 305             Assert.AreEqual(location, plugin.GetLocation());\r
 306             Assert.AreEqual(version, plugin.Version);\r
 307         }\r
 308 \r
 309         public class Plugin1 : Plugin\r
 310         {\r
 311         }\r
 312 \r
 313         [TestMethod]\r
 314         public void Export_Plugin1()\r
 315         {\r
 316             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 317                 typeof(Plugin1));\r
 318 \r
 319             VerifyValidPlugin(container, 0, "NoWhere");\r
 320         }\r
 321 \r
 322         public class Plugin2 : Plugin\r
 323         {\r
 324             public override string GetLocation()\r
 325             {\r
 326                 return "SomeWhere";\r
 327             }\r
 328             public override int Version\r
 329             {\r
 330                 get\r
 331                 {\r
 332                     return 1;\r
 333                 }\r
 334             }\r
 335         }\r
 336 \r
 337         [TestMethod]\r
 338         public void Export_Plugin2()\r
 339         {\r
 340             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 341                 typeof(Plugin2));\r
 342 \r
 343             VerifyValidPlugin(container, 1, "SomeWhere");\r
 344         }\r
 345 \r
 346         public class Plugin3 : Plugin\r
 347         {\r
 348             [Export("PluginLocation")]\r
 349             public override string GetLocation()\r
 350             {\r
 351                 return "SomeWhere3";\r
 352             }\r
 353 \r
 354             [Export("PluginVersion")]\r
 355             public override int Version\r
 356             {\r
 357                 get\r
 358                 {\r
 359                     return 3;\r
 360                 }\r
 361             }\r
 362         }\r
 363 \r
 364         [TestMethod]\r
 365         public void Export_Plugin3()\r
 366         {\r
 367             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 368                 typeof(Plugin3));\r
 369 \r
 370             VerifyValidPlugin(container, 3, "SomeWhere3");\r
 371 \r
 372             var plVer = container.GetExportedValue<int>("PluginVersion");\r
 373             Assert.AreEqual(3, plVer);\r
 374 \r
 375             var plLoc = container.GetExportedValue<Func<string>>("PluginLocation");\r
 376             Assert.AreEqual("SomeWhere3", plLoc());\r
 377         }\r
 378 \r
 379         [InheritedExport(typeof(Plugin))]\r
 380         public class Plugin4 : Plugin\r
 381         {\r
 382             public override string GetLocation()\r
 383             {\r
 384                 return "SomeWhere4";\r
 385             }\r
 386 \r
 387             public override int Version\r
 388             {\r
 389                 get\r
 390                 {\r
 391                     return 4;\r
 392                 }\r
 393             }\r
 394         }\r
 395 \r
 396         [TestMethod]\r
 397         public void Export_Plugin4()\r
 398         {\r
 399             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 400                 typeof(Plugin4));\r
 401 \r
 402             VerifyValidPlugin(container, 4, "SomeWhere4");\r
 403         }\r
 404 \r
 405         \r
 406         public interface IPlugin\r
 407         {\r
 408             int Id { get; }\r
 409         }\r
 410         \r
 411         public class MyPlugin : IPlugin\r
 412         {\r
 413             [Export("PluginId")]\r
 414             public int Id { get { return 0; } }\r
 415         }\r
 416 \r
 417         [TestMethod]\r
 418         public void Export_MyPlugin()\r
 419         {\r
 420             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 421                 typeof(MyPlugin));\r
 422 \r
 423             var export = container.GetExportedValue<int>("PluginId");\r
 424         }\r
 425 \r
 426         [InheritedExport]\r
 427         public interface IApplicationPlugin\r
 428         {\r
 429             string Name { get; }\r
 430             \r
 431             object Application { get; set; }\r
 432         }\r
 433 \r
 434         [InheritedExport]\r
 435         public interface IToolbarPlugin : IApplicationPlugin\r
 436         {\r
 437             object ToolBar { get; set; }\r
 438         }\r
 439 \r
 440         public class MyToolbarPlugin : IToolbarPlugin\r
 441         {\r
 442             [Export("ApplicationPluginNames")]\r
 443             public string Name { get { return "MyToolbarPlugin"; } }\r
 444 \r
 445             [Import("Application")]\r
 446             public object Application { get; set; }\r
 447 \r
 448             [Import("ToolBar")]\r
 449             public object ToolBar { get; set; }\r
 450         }\r
 451 \r
 452         [TestMethod]\r
 453         public void TestInterfaces()\r
 454         {\r
 455             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 456                 typeof(MyToolbarPlugin));\r
 457 \r
 458             var app = new object();\r
 459             container.AddAndComposeExportedValue<object>("Application", app);\r
 460 \r
 461             var toolbar = new object();\r
 462             container.AddAndComposeExportedValue<object>("ToolBar", toolbar);\r
 463 \r
 464             var export = container.GetExportedValue<IToolbarPlugin>();\r
 465 \r
 466             Assert.AreEqual(app, export.Application);\r
 467             Assert.AreEqual(toolbar, export.ToolBar);\r
 468             Assert.AreEqual("MyToolbarPlugin", export.Name);\r
 469 \r
 470             var pluginNames = container.GetExportedValues<string>("ApplicationPluginNames");\r
 471             Assert.AreEqual(1, pluginNames.Count());\r
 472         }\r
 473 \r
 474         public class ImportOnVirtualProperty\r
 475         {\r
 476             public int ImportSetCount = 0;\r
 477             private int _value;\r
 478 \r
 479             [Import("VirtualImport")]\r
 480             public virtual int VirtualImport \r
 481             {\r
 482                 get\r
 483                 {\r
 484                     return this._value;\r
 485                 }\r
 486                 set\r
 487                 {\r
 488                     this._value = value;\r
 489                     ImportSetCount++;\r
 490                 }\r
 491             }\r
 492         }\r
 493 \r
 494         public class ImportOnOverridenPropertyWithSameContract : ImportOnVirtualProperty\r
 495         {\r
 496             [Import("VirtualImport")]\r
 497             public override int VirtualImport\r
 498             {\r
 499                 get\r
 500                 {\r
 501                     return base.VirtualImport;\r
 502                 }\r
 503                 set\r
 504                 {\r
 505                     base.VirtualImport = value;\r
 506                 }\r
 507             }\r
 508         }\r
 509 \r
 510         [TestMethod]\r
 511         public void Import_VirtualPropertyOverrideWithSameContract_ShouldSucceed()\r
 512         {\r
 513             var container = ContainerFactory.Create();\r
 514             container.AddAndComposeExportedValue<int>("VirtualImport", 21);\r
 515 \r
 516             var import = new ImportOnOverridenPropertyWithSameContract();\r
 517 \r
 518             container.SatisfyImportsOnce(import);\r
 519 \r
 520             // Import will get set twice because there are 2 imports on the same property.\r
 521             // We would really like to either elminate it getting set twice or error in this case\r
 522             // but we figure it is a rare enough corner case that it doesn't warrented the run time cost\r
 523             // and can be covered by an FxCop rule.\r
 524 \r
 525             Assert.AreEqual(2, import.ImportSetCount);\r
 526             Assert.AreEqual(21, import.VirtualImport);\r
 527         }\r
 528 \r
 529         public class ImportOnOverridenPropertyWithDifferentContract : ImportOnVirtualProperty\r
 530         {\r
 531             [Import("OverriddenImport")]\r
 532             public override int VirtualImport\r
 533             {\r
 534                 set\r
 535                 {\r
 536                     base.VirtualImport = value;\r
 537                 }\r
 538             }\r
 539         }\r
 540 \r
 541         [TestMethod]\r
 542         public void Import_VirtualPropertyOverrideWithDifferentContract_ShouldSucceed()\r
 543         {\r
 544             var container = ContainerFactory.Create();\r
 545             container.AddAndComposeExportedValue<int>("VirtualImport", 21);\r
 546             container.AddAndComposeExportedValue<int>("OverriddenImport", 42);\r
 547 \r
 548             var import = new ImportOnOverridenPropertyWithSameContract();\r
 549 \r
 550             container.SatisfyImportsOnce(import);\r
 551 \r
 552             // Import will get set twice because there are 2 imports on the same property.\r
 553             // We would really like to either elminate it getting set twice or error in this case\r
 554             // but we figure it is a rare enough corner case that it doesn't warrented the run time cost\r
 555             // and can be covered by an FxCop rule.\r
 556 \r
 557             Assert.AreEqual(2, import.ImportSetCount);\r
 558 \r
 559             // The derived most import should be discovered first and so it will get set first\r
 560             // and thus the value should be the base import which is 21.\r
 561             Assert.AreEqual(21, import.VirtualImport);\r
 562         }\r
 563 \r
 564         [InheritedExport]\r
 565         public interface IOrderScreen { }\r
 566 \r
 567         public class NorthwindOrderScreen : IOrderScreen\r
 568         {\r
 569         }\r
 570 \r
 571         public class SouthsandOrderScreen : IOrderScreen\r
 572         {\r
 573         }\r
 574 \r
 575         [TestMethod]\r
 576         public void Export_ExportOnlyOnBaseInterfacewithInheritedMarked_ShouldFindAllImplementers()\r
 577         {\r
 578             var container = ContainerFactory.CreateWithAttributedCatalog(\r
 579                 typeof(NorthwindOrderScreen),\r
 580                 typeof(SouthsandOrderScreen));\r
 581 \r
 582             var exports = container.GetExportedValues<IOrderScreen>();\r
 583 \r
 584             Assert.AreEqual(2, exports.Count());\r
 585             Assert.IsInstanceOfType(exports.ElementAt(0), typeof(NorthwindOrderScreen));\r
 586             Assert.IsInstanceOfType(exports.ElementAt(1), typeof(SouthsandOrderScreen));\r
 587         }\r
 588 \r
 589         [Export]\r
 590         public class PartWithStaticConstructor\r
 591         {\r
 592             static PartWithStaticConstructor()\r
 593             {\r
 594                 throw new Exception();\r
 595             }\r
 596         }\r
 597 \r
 598         [TestMethod]\r
 599         public void StaticConstructor()\r
 600         {\r
 601             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(PartWithStaticConstructor));\r
 602 \r
 603             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue,\r
 604                 ErrorId.ImportEngine_PartCannotActivate, \r
 605                 ErrorId.ReflectionModel_PartConstructorThrewException,\r
 606                 () => container.GetExportedValue<PartWithStaticConstructor>());\r
 607         }\r
 608 \r
 609         public interface IAddin\r
 610         {\r
 611             void LoadAddin(object application);\r
 612             void Shutdown();\r
 613         }\r
 614 \r
 615         public interface IAddinMetadata\r
 616         {\r
 617             string Name { get; }\r
 618             string Version { get; }\r
 619             string Id { get; }\r
 620         }\r
 621 \r
 622         [MetadataAttribute]\r
 623         [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]\r
 624         public class AddinAttribute : ExportAttribute, IAddinMetadata\r
 625         {\r
 626             private string _name;\r
 627             private string _version;\r
 628             private string _id;\r
 629 \r
 630             public AddinAttribute(string name, string version, string id)\r
 631                 : base(typeof(IAddin))\r
 632             {\r
 633                 this._name = name;\r
 634                 this._version = version;\r
 635                 this._id = id;\r
 636             }\r
 637 \r
 638             public string Name { get { return this._name; } }\r
 639             public string Version { get { return this._version; } }\r
 640             public string Id { get { return this._id; } }\r
 641         }\r
 642 \r
 643 \r
 644         [Addin("Addin1", "1.0", "{63D1B00F-AD2F-4F14-8A36-FFA59E4A101C}")]\r
 645         public class Addin1 : IAddin\r
 646         {\r
 647             public void LoadAddin(object application)\r
 648             {\r
 649             }\r
 650             public void Shutdown()\r
 651             {\r
 652             }\r
 653         }\r
 654 \r
 655         [Addin("Addin2", "1.0", "{63D1B00F-AD2F-4F14-8A36-FFA59E4A101D}")]\r
 656         public class Addin2 : IAddin\r
 657         {\r
 658             public void LoadAddin(object application)\r
 659             {\r
 660             }\r
 661             public void Shutdown()\r
 662             {\r
 663             }\r
 664         }\r
 665 \r
 666         [Addin("Addin3", "1.0", "{63D1B00F-AD2F-4F14-8A36-FFA59E4A101E}")]\r
 667         public class Addin3 : IAddin\r
 668         {\r
 669             public void LoadAddin(object application)\r
 670             {\r
 671             }\r
 672             public void Shutdown()\r
 673             {\r
 674             }\r
 675         }\r
 676 \r
 677         [TestMethod]\r
 678         public void DiscoverAddinsWithCombinedCustomExportAndMetadataAttribute()\r
 679         {\r
 680             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Addin1), typeof(Addin2), typeof(Addin3));\r
 681 \r
 682             var addins = container.GetExports<IAddin, IAddinMetadata>().ToArray();\r
 683 \r
 684             Assert.AreEqual(3, addins.Length, "Incorrect number of addins");\r
 685 \r
 686             var values = new AddinAttribute[] \r
 687                 {\r
 688                     new AddinAttribute("Addin1", "1.0", "{63D1B00F-AD2F-4F14-8A36-FFA59E4A101C}"),\r
 689                     new AddinAttribute("Addin2", "1.0", "{63D1B00F-AD2F-4F14-8A36-FFA59E4A101D}"),\r
 690                     new AddinAttribute("Addin3", "1.0", "{63D1B00F-AD2F-4F14-8A36-FFA59E4A101E}"),\r
 691                 };\r
 692 \r
 693             for (int i = 0; i < values.Length; i++)\r
 694             {\r
 695                 var addinMetadata = addins[i].Metadata;\r
 696 \r
 697                 Assert.AreEqual(values[i].Name, addinMetadata.Name);\r
 698                 Assert.AreEqual(values[i].Version, addinMetadata.Version);\r
 699                 Assert.AreEqual(values[i].Id, addinMetadata.Id);\r
 700             }\r
 701         }\r
 702 \r
 703         [TestMethod]\r
 704         public void CombinedCustomExportMetadataAttribute_ShouldNotContainMetadataFromExportAttribute()\r
 705         {\r
 706             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(Addin1));\r
 707             var addin = container.GetExport<IAddin, IDictionary<string, object>>();\r
 708 \r
 709             Assert.AreEqual(4, addin.Metadata.Count); // 3 metadata values and type identity\r
 710 \r
 711             Assert.AreEqual(AttributedModelServices.GetTypeIdentity(typeof(IAddin)), addin.Metadata[CompositionConstants.ExportTypeIdentityMetadataName]);\r
 712             Assert.AreEqual("Addin1", addin.Metadata["Name"]);\r
 713             Assert.AreEqual("1.0", addin.Metadata["Version"]);\r
 714             Assert.AreEqual("{63D1B00F-AD2F-4F14-8A36-FFA59E4A101C}", addin.Metadata["Id"]);\r
 715         }\r
 716 \r
 717         public class CustomInheritedExportAttribute : InheritedExportAttribute\r
 718         {\r
 719         }\r
 720 \r
 721         [CustomInheritedExport]\r
 722         public interface IUsesCustomInheritedExport\r
 723         {\r
 724             int Property { get; }\r
 725         }\r
 726 \r
 727         public class UsesCustomInheritedExportOnInterface : IUsesCustomInheritedExport\r
 728         {\r
 729             public int Property\r
 730             {\r
 731                 get { return 42; }\r
 732             }\r
 733         }\r
 734 \r
 735         [TestMethod]\r
 736         public void Test_CustomInheritedExportAttribute_OnInterface()\r
 737         {\r
 738             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(UsesCustomInheritedExportOnInterface));\r
 739             var exporter = container.GetExportedValue<IUsesCustomInheritedExport>();\r
 740             Assert.AreEqual(42, exporter.Property);\r
 741         }\r
 742 \r
 743         [CustomInheritedExport]\r
 744         public class BaseClassWithCustomInheritedExport\r
 745         {\r
 746             public int Property { get; set; }\r
 747         }\r
 748 \r
 749         public class DerivedFromBaseWithCustomInheritedExport : BaseClassWithCustomInheritedExport\r
 750         {\r
 751             public DerivedFromBaseWithCustomInheritedExport()\r
 752             {\r
 753                 Property = 43;\r
 754             }\r
 755         }\r
 756 \r
 757         [TestMethod]\r
 758         public void Test_CustomInheritedExportAttribute_OnBaseClass()\r
 759         {\r
 760             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(DerivedFromBaseWithCustomInheritedExport));\r
 761             var exporter = container.GetExportedValue<BaseClassWithCustomInheritedExport>();\r
 762             Assert.AreEqual(43, exporter.Property);\r
 763         }\r
 764 \r
 765 \r
 766         [InheritedExport("Foo")]\r
 767         [ExportMetadata("Name", "IFoo1")]\r
 768         public interface IFoo1 { }\r
 769 \r
 770         [InheritedExport("Foo")]\r
 771         [ExportMetadata("Name", "IFoo2")]\r
 772         public interface IFoo2 { }\r
 773 \r
 774         [InheritedExport("Foo")]\r
 775         [ExportMetadata("Name", "FooWithOneFoo")]\r
 776         public class FooWithOneFoo : IFoo1\r
 777         {\r
 778         }\r
 779 \r
 780         [TestMethod]\r
 781         public void InheritedExport_OnTypeAndInterface()\r
 782         {\r
 783             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(FooWithOneFoo));\r
 784 \r
 785             var foos = container.GetExports<object, IDictionary<string, object>>("Foo").ToArray();\r
 786 \r
 787             Assert.AreEqual(1, foos.Length);\r
 788             Assert.AreEqual("FooWithOneFoo", foos[0].Metadata["Name"]);\r
 789         }\r
 790 \r
 791         public class FooWithTwoFoos : IFoo1, IFoo2 { }\r
 792 \r
 793         [TestMethod]\r
 794         public void InheritedExport_TwoInterfaces()\r
 795         {\r
 796             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(FooWithTwoFoos));\r
 797 \r
 798             var foos = container.GetExports<object, IDictionary<string, object>>("Foo").ToArray();\r
 799 \r
 800             Assert.AreEqual(2, foos.Length);\r
 801 \r
 802             EnumerableAssert.AreEqual(foos.Select(e => (string)e.Metadata["Name"]), "IFoo1", "IFoo2");\r
 803         }\r
 804 \r
 805         public class FooWithIfaceByOneFoo : FooWithOneFoo, IFoo1 { }\r
 806 \r
 807         [TestMethod]\r
 808         public void InheritedExport_BaseAndInterface()\r
 809         {\r
 810             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(FooWithIfaceByOneFoo));\r
 811 \r
 812             var foos = container.GetExports<object, IDictionary<string, object>>("Foo").ToArray();\r
 813 \r
 814             Assert.AreEqual(1, foos.Length);\r
 815 \r
 816             Assert.AreEqual("FooWithOneFoo", foos[0].Metadata["Name"]);\r
 817         }\r
 818 \r
 819         [InheritedExport("Foo")]\r
 820         [ExportMetadata("Name", "FooWithInheritedOnSelf")]\r
 821         public class FooWithInheritedOnSelf : FooWithOneFoo, IFoo1 { }\r
 822 \r
 823         [TestMethod]\r
 824         public void InheritedExport_BaseInterfaceAndSelf()\r
 825         {\r
 826             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(FooWithInheritedOnSelf));\r
 827 \r
 828             var foos = container.GetExports<object, IDictionary<string, object>>("Foo").ToArray();\r
 829 \r
 830             Assert.AreEqual(1, foos.Length);\r
 831 \r
 832             Assert.AreEqual("FooWithInheritedOnSelf", foos[0].Metadata["Name"]);\r
 833         }\r
 834 \r
 835         [InheritedExport("Foo")]\r
 836         [ExportMetadata("Name", "IFoo3")]\r
 837         public interface IFoo3 : IFoo1 { }\r
 838 \r
 839         public class FooWithInterfaceWithMultipleFoos : IFoo3 { }\r
 840 \r
 841         [TestMethod]\r
 842         public void InheritedExport_InterfaceHiearchy()\r
 843         {\r
 844             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(FooWithInterfaceWithMultipleFoos));\r
 845 \r
 846             var foos = container.GetExports<object, IDictionary<string, object>>("Foo").ToArray();\r
 847             Assert.AreEqual(2, foos.Length);\r
 848 \r
 849             EnumerableAssert.AreEqual(foos.Select(e => (string)e.Metadata["Name"]), "IFoo1", "IFoo3");\r
 850         }\r
 851 \r
 852         [InheritedExport("Foo2")]\r
 853         [ExportMetadata("Name", "FooWithMultipleInheritedExports")]\r
 854         public class FooWithMultipleInheritedExports : IFoo1 { }\r
 855 \r
 856         [TestMethod]\r
 857         public void InheritedExport_MultipleDifferentContracts()\r
 858         {\r
 859             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(FooWithMultipleInheritedExports));\r
 860 \r
 861             var foos = container.GetExports<object, IDictionary<string, object>>("Foo").ToArray();\r
 862 \r
 863             Assert.AreEqual(1, foos.Length);\r
 864 \r
 865             Assert.AreEqual("IFoo1", foos[0].Metadata["Name"]);\r
 866 \r
 867             var foo2s = container.GetExports<object, IDictionary<string, object>>("Foo2").ToArray();\r
 868 \r
 869             Assert.AreEqual(1, foo2s.Length);\r
 870 \r
 871             Assert.AreEqual("FooWithMultipleInheritedExports", foo2s[0].Metadata["Name"]);\r
 872         }\r
 873     }\r
 874 }\r