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

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Linq;\r
   6 using System.ComponentModel.Composition;\r
   7 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
   8 using System.ComponentModel.Composition.UnitTesting;\r
   9 using System.ComponentModel.Composition.Factories;\r
  10 using System.ComponentModel.Composition.Primitives;\r
  11 \r
  12 namespace Tests.Integration\r
  13 {  \r
  14     [TestClass]\r
  15     public class CompositionContainerAttributedModelCycleTests\r
  16     {\r
  17         // There are nine possible scenarios that cause a part to have a dependency on another part, some of which\r
  18         // are legal and some not. For example, below, is not legal for a part, A, to have a prerequisite dependency\r
  19         // on a part, B, which has also has a prerequisite dependency on A. In contrast, however, it is legal for \r
  20         // part A and B to have a non-prerequisite (Post) dependency on each other.\r
  21         // \r
  22         // ------------------------------\r
  23         // |        |         B         |\r
  24         // |        | Pre | Post | None |\r
  25         // |--------|-----|------|------|\r
  26         // |   Pre  |  X  |    X |    √ |\r
  27         // | A Post |  X  |    √ |    √ |\r
  28         // |   None |  √  |    √ |    √ |\r
  29         // ------------------------------\r
  30         //\r
  31 \r
  32         [TestMethod]\r
  33         public void APrerequisiteDependsOnBPrerequisite_ShouldThrowComposition()\r
  34         {\r
  35             AssertCycle(typeof(APrerequisiteDependsOnBPrerequisite), \r
  36                         typeof(BPrerequisiteDependsOnAPrerequisite));\r
  37         }\r
  38 \r
  39         [TestMethod]\r
  40         public void APrerequisiteDependsOnBPost_ShouldThrowComposition()\r
  41         {\r
  42             AssertCycle(typeof(APrerequisiteDependsOnBPost),\r
  43                         typeof(BPostDependsOnAPrerequisite));\r
  44         }\r
  45 \r
  46         [TestMethod]\r
  47         public void APrerequisiteDependsOnBNone_ShouldNotThrow()\r
  48         {\r
  49             AssertNotCycle(typeof(APrerequisiteDependsOnBNone), \r
  50                            typeof(BNone));\r
  51         }\r
  52 \r
  53         [TestMethod]\r
  54         public void APostDependsOnBPrerequisite_ShouldThrowComposition()\r
  55         {\r
  56             AssertCycle(typeof(APostDependsOnBPrerequisite), \r
  57                         typeof(BPrerequisiteDependsOnAPost));\r
  58         }\r
  59 \r
  60         [TestMethod]\r
  61         public void APostDependsOnBPost_ShouldNotThrow()\r
  62         {\r
  63             AssertNotCycle(typeof(APostDependsOnBPost), \r
  64                            typeof(BPostDependsOnAPost));\r
  65         }\r
  66 \r
  67         [TestMethod]\r
  68         public void APostDependsOnBNone_ShouldNotThrow()\r
  69         {\r
  70             AssertNotCycle(typeof(APostDependsOnBNone), \r
  71                            typeof(BNone));\r
  72         }\r
  73 \r
  74         [TestMethod]\r
  75         public void BPrerequisiteDependsOnANone_ShouldNotThrow()\r
  76         {\r
  77             AssertNotCycle(typeof(ANone),\r
  78                            typeof(BPrerequisiteDependsOnANone));\r
  79         }\r
  80 \r
  81         [TestMethod]\r
  82         public void BPostDependsOnANone_ShouldNotThrow()\r
  83         {\r
  84             AssertNotCycle(typeof(ANone),\r
  85                            typeof(BPostDependsOnANone));\r
  86         }\r
  87 \r
  88         [TestMethod]\r
  89         public void ANoneWithBNone_ShouldNotThrow()\r
  90         {\r
  91             AssertNotCycle(typeof(ANone),\r
  92                            typeof(BNone));\r
  93         }\r
  94 \r
  95         [TestMethod]\r
  96         public void PartWithHasPrerequisteImportThatIsInAPostCycle_ShouldNotThrow()\r
  97         {\r
  98             AssertNotCycle(typeof(PartWithHasPrerequisteImportThatIsInAPostCycle)\r
  99                 , typeof(APostDependsOnBPost), typeof(BPostDependsOnAPost));\r
 100         }\r
 101 \r
 102         private static void AssertCycle(params Type[] types)\r
 103         {\r
 104             foreach (Type type in types)\r
 105             {\r
 106                 var export = GetExport(type, types);\r
 107 \r
 108                 CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue, () =>\r
 109                 {\r
 110                     var value = export.Value;\r
 111                 });\r
 112             }\r
 113         }\r
 114 \r
 115         private static void AssertNotCycle(params Type[] types)\r
 116         {\r
 117             foreach (Type type in types)\r
 118             {\r
 119                 var export = GetExport(type, types);\r
 120 \r
 121                 Assert.IsInstanceOfType(export.Value, type);\r
 122             }\r
 123         }\r
 124 \r
 125         private static Lazy<object, object> GetExport(Type type, Type[] partTypes)\r
 126         {\r
 127             var container = ContainerFactory.CreateWithAttributedCatalog(partTypes);\r
 128 \r
 129             return container.GetExports(type, null, null).Single();\r
 130         }\r
 131 \r
 132         [Export]\r
 133         public class APrerequisiteDependsOnBPrerequisite\r
 134         {\r
 135             [ImportingConstructor]\r
 136             public APrerequisiteDependsOnBPrerequisite(BPrerequisiteDependsOnAPrerequisite b)\r
 137             {\r
 138             }\r
 139         }\r
 140 \r
 141         [Export]\r
 142         public class BPrerequisiteDependsOnAPrerequisite\r
 143         {\r
 144             [ImportingConstructor]\r
 145             public BPrerequisiteDependsOnAPrerequisite(APrerequisiteDependsOnBPrerequisite a)\r
 146             {\r
 147             }\r
 148         }\r
 149 \r
 150 \r
 151         [Export]\r
 152         public class APrerequisiteDependsOnBPost\r
 153         {\r
 154             [ImportingConstructor]\r
 155             public APrerequisiteDependsOnBPost(BPostDependsOnAPrerequisite b)\r
 156             {\r
 157             }\r
 158         }\r
 159 \r
 160         [Export]\r
 161         public class BPostDependsOnAPrerequisite\r
 162         {\r
 163             [Import]\r
 164             public APrerequisiteDependsOnBPost A\r
 165             {\r
 166                 get;\r
 167                 set;\r
 168             }\r
 169         }\r
 170 \r
 171         [Export]\r
 172         public class APrerequisiteDependsOnBNone\r
 173         {\r
 174             [ImportingConstructor]\r
 175             public APrerequisiteDependsOnBNone(BNone b)\r
 176             {\r
 177             }\r
 178         }\r
 179 \r
 180         [Export]\r
 181         public class BNone\r
 182         {\r
 183         }\r
 184 \r
 185 \r
 186         [Export]\r
 187         public class ANone\r
 188         {\r
 189         }\r
 190 \r
 191         [Export]\r
 192         public class APostDependsOnBPrerequisite\r
 193         {\r
 194             [Import]\r
 195             public BPrerequisiteDependsOnAPost B\r
 196             {\r
 197                 get;\r
 198                 set;\r
 199             }\r
 200         }\r
 201 \r
 202         [Export]\r
 203         public class BPrerequisiteDependsOnAPost\r
 204         {\r
 205             [ImportingConstructor]\r
 206             public BPrerequisiteDependsOnAPost(APostDependsOnBPrerequisite a)\r
 207             {\r
 208             }\r
 209         }\r
 210 \r
 211 \r
 212         [Export]\r
 213         public class APostDependsOnBPost\r
 214         {\r
 215             [Import]\r
 216             public BPostDependsOnAPost B\r
 217             {\r
 218                 get;\r
 219                 set;\r
 220             }\r
 221         }\r
 222 \r
 223         [Export]\r
 224         public class BPostDependsOnAPost\r
 225         {\r
 226             [Import]\r
 227             public APostDependsOnBPost A\r
 228             {\r
 229                 get;\r
 230                 set;\r
 231             }\r
 232         }\r
 233 \r
 234         [Export]\r
 235         public class APostDependsOnBNone\r
 236         {\r
 237             [Import]\r
 238             public BNone B\r
 239             {\r
 240                 get;\r
 241                 set;\r
 242             }\r
 243         }\r
 244 \r
 245         [Export]\r
 246         public class BPrerequisiteDependsOnANone\r
 247         {\r
 248             [ImportingConstructor]\r
 249             public BPrerequisiteDependsOnANone(ANone a)\r
 250             {\r
 251             }\r
 252         }\r
 253 \r
 254         [Export]\r
 255         public class BPostDependsOnANone\r
 256         {\r
 257             [Import]\r
 258             public ANone A\r
 259             {\r
 260                 get;\r
 261                 set;\r
 262             }\r
 263         }\r
 264 \r
 265         [Export]\r
 266         public class PartWithHasPrerequisteImportThatIsInAPostCycle\r
 267         {\r
 268             [ImportingConstructor]\r
 269             public PartWithHasPrerequisteImportThatIsInAPostCycle(APostDependsOnBPost a)\r
 270             {\r
 271             }\r
 272         }\r
 273     }\r
 274 }\r