mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/AttributedModel/AttributedModelCompositionTests.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.Factories;\r
   7 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
   8 using System.UnitTesting;\r
   9 using System.ComponentModel.Composition.Hosting;\r
  10 using System.ComponentModel.Composition.UnitTesting;\r
  11 \r
  12 namespace System.ComponentModel.Composition.AttributedModel\r
  13 {\r
  14     [TestClass]\r
  15     public class AttributedModelCompositionTests\r
  16     {\r
  17         [TestMethod]\r
  18         public void PartContainingOnlyStaticExports_ShouldNotCauseInstanceToBeCreated()\r
  19         {  \r
  20             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(HasOnlyStaticExports));\r
  21             \r
  22             Assert.AreEqual("Field", container.GetExportedValue<string>("Field"));\r
  23             Assert.AreEqual("Property", container.GetExportedValue<string>("Property"));\r
  24             Assert.IsNotNull("Method", container.GetExportedValue<Func<string>>("Method")());\r
  25 \r
  26             Assert.IsFalse(HasOnlyStaticExports.InstanceCreated);\r
  27         }\r
  28 \r
  29         [TestMethod]\r
  30         public void ExportOnAbstractBase_DoesNotReturnNull()\r
  31         {   // 499393 - Classes inheriting from an exported \r
  32             // abstract class are exported as 'null'\r
  33 \r
  34             var container = ContainerFactory.Create();\r
  35             CompositionBatch batch = new CompositionBatch();\r
  36 \r
  37             var definition = PartDefinitionFactory.CreateAttributed(typeof(Derived));\r
  38             batch.AddPart(definition.CreatePart());\r
  39             container.Compose(batch);\r
  40 \r
  41             Assert.IsNotNull(container.GetExportedValueOrDefault<Base>());\r
  42         }\r
  43 \r
  44         [TestMethod]\r
  45         public void ReadOnlyFieldImport_ShouldThrowComposition()\r
  46         {\r
  47             var importer = PartFactory.CreateAttributed(new ReadOnlyPropertyImport());\r
  48             var container = ContainerFactory.Create();\r
  49             CompositionBatch batch = new CompositionBatch();\r
  50             batch.AddPart(importer);\r
  51             batch.AddExportedValue("readonly", "new value");\r
  52 \r
  53             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,\r
  54                                           ErrorId.ReflectionModel_ImportNotWritable,\r
  55                                           RetryMode.DoNotRetry, () =>\r
  56             {\r
  57                 container.Compose(batch);\r
  58             });\r
  59         }\r
  60 \r
  61         [TestMethod]\r
  62         public void ReadOnlyPropertyImport_ShouldThrowComposition()\r
  63         {\r
  64             var importer = PartFactory.CreateAttributed(new ReadOnlyPropertyImport());\r
  65             var container = ContainerFactory.Create();\r
  66             CompositionBatch batch = new CompositionBatch();\r
  67             batch.AddPart(importer);\r
  68             batch.AddExportedValue("readonly", "new value");\r
  69 \r
  70             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,\r
  71                                           ErrorId.ReflectionModel_ImportNotWritable, RetryMode.DoNotRetry, () =>\r
  72             {\r
  73                 container.Compose(batch);\r
  74             });\r
  75         }\r
  76 \r
  77         [TestMethod]\r
  78         public void WriteOnlyPropertyExport_ShouldThrowComposition()\r
  79         {\r
  80             var importer = PartFactory.CreateAttributed(new WriteOnlyPropertyExport());\r
  81             var container = ContainerFactory.Create();\r
  82             CompositionBatch batch = new CompositionBatch();\r
  83             batch.AddPart(importer);\r
  84             container.Compose(batch);\r
  85 \r
  86             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue, ErrorId.ReflectionModel_ExportNotReadable, () =>\r
  87             {\r
  88                 container.GetExportedValue<string>("writeonly");\r
  89             });\r
  90         }\r
  91 \r
  92         [TestMethod]\r
  93         public void ImportValueMismatchFromInt32ToDateTime()\r
  94         {\r
  95             var container = ContainerFactory.Create();\r
  96             CompositionBatch batch = new CompositionBatch();\r
  97             batch.AddPart(new ImportValueTypes());\r
  98             batch.AddExportedValue("DateTime", typeof(DateTime), 42);\r
  99 \r
 100             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 101                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 102                                           RetryMode.DoNotRetry, () =>\r
 103             {\r
 104                 container.Compose(batch);\r
 105             });\r
 106         }\r
 107 \r
 108         [TestMethod]\r
 109         public void ImportValueMismatchFromInt16ToInt32()\r
 110         {\r
 111             var container = ContainerFactory.Create();\r
 112             CompositionBatch batch = new CompositionBatch();\r
 113 \r
 114             batch.AddPart(new ImportValueTypes());\r
 115             batch.AddExportedValue("Int32", typeof(Int32), (short)10);\r
 116 \r
 117             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 118                               ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 119                               RetryMode.DoNotRetry, () =>\r
 120             {\r
 121                 container.Compose(batch);\r
 122             });\r
 123 \r
 124         }\r
 125 \r
 126         [TestMethod]\r
 127         public void ImportValueMismatchFromInt32ToInt16()\r
 128         {\r
 129             var container = ContainerFactory.Create();\r
 130             CompositionBatch batch = new CompositionBatch();\r
 131 \r
 132             batch.AddPart(new ImportValueTypes());\r
 133             batch.AddExportedValue("Int16", typeof(Int16), (int)10);\r
 134 \r
 135             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 136                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 137                                           RetryMode.DoNotRetry, () =>\r
 138             {\r
 139                 container.Compose(batch);\r
 140             });\r
 141         }\r
 142 \r
 143         [TestMethod]\r
 144         public void ImportValueMismatchFromInt32ToUInt32()\r
 145         {\r
 146             var container = ContainerFactory.Create();\r
 147             CompositionBatch batch = new CompositionBatch();\r
 148 \r
 149             batch.AddPart(new ImportValueTypes());\r
 150             batch.AddExportedValue("UInt32", typeof(UInt32), (int)10);\r
 151 \r
 152             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 153                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 154                                           RetryMode.DoNotRetry, () =>\r
 155             {\r
 156                 container.Compose(batch);\r
 157             });\r
 158         }\r
 159 \r
 160         [TestMethod]\r
 161         public void ImportValueMismatchFromUInt32ToInt32()\r
 162         {\r
 163             var container = ContainerFactory.Create();\r
 164             CompositionBatch batch = new CompositionBatch();\r
 165 \r
 166             batch.AddPart(new ImportValueTypes());\r
 167             batch.AddExportedValue("Int32", typeof(Int32), (uint)10);\r
 168 \r
 169             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 170                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 171                                           RetryMode.DoNotRetry, () =>\r
 172             {\r
 173                 container.Compose(batch);\r
 174             });\r
 175         }\r
 176 \r
 177         [TestMethod]\r
 178         public void ImportValueMismatchFromInt32ToInt64()\r
 179         {\r
 180             var container = ContainerFactory.Create();\r
 181             CompositionBatch batch = new CompositionBatch();\r
 182 \r
 183             batch.AddPart(new ImportValueTypes());\r
 184             batch.AddExportedValue("Int64", typeof(Int64), (int)10);\r
 185 \r
 186             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 187                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 188                                           RetryMode.DoNotRetry, () =>\r
 189             {\r
 190                 container.Compose(batch);\r
 191             });\r
 192         }\r
 193 \r
 194         [TestMethod]\r
 195         public void ImportValueMismatchFromSingleToDouble()\r
 196         {\r
 197             var container = ContainerFactory.Create();\r
 198             CompositionBatch batch = new CompositionBatch();\r
 199 \r
 200             batch.AddPart(new ImportValueTypes());\r
 201             batch.AddExportedValue("Double", typeof(Double), (float)10);\r
 202 \r
 203             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 204                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 205                                           RetryMode.DoNotRetry, () =>\r
 206             {\r
 207                 container.Compose(batch);\r
 208             });\r
 209         }\r
 210 \r
 211         [TestMethod]\r
 212         public void ImportValueMismatchFromDoubleToSingle()\r
 213         {\r
 214             var container = ContainerFactory.Create(); \r
 215             CompositionBatch batch = new CompositionBatch();\r
 216 \r
 217             batch.AddPart(new ImportValueTypes());\r
 218             batch.AddExportedValue("Single", typeof(Single), (double)10);\r
 219 \r
 220             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 221                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 222                                           RetryMode.DoNotRetry, () =>\r
 223             {\r
 224                 container.Compose(batch);\r
 225             });\r
 226         }\r
 227 \r
 228         [TestMethod]\r
 229         public void ImportValueMismatchFromSingleToInt32()\r
 230         {\r
 231             var container = ContainerFactory.Create();\r
 232             CompositionBatch batch = new CompositionBatch();\r
 233 \r
 234             batch.AddPart(new ImportValueTypes());\r
 235             batch.AddExportedValue("Int32", typeof(Int32), (float)10);\r
 236 \r
 237             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 238                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 239                                           RetryMode.DoNotRetry, () =>\r
 240             {\r
 241                 container.Compose(batch);\r
 242             });\r
 243         }\r
 244 \r
 245         [TestMethod]\r
 246         public void ImportValueMismatchFromInt32ToSingle()\r
 247         {\r
 248             var container = ContainerFactory.Create();\r
 249             CompositionBatch batch = new CompositionBatch();\r
 250 \r
 251             batch.AddPart(new ImportValueTypes());\r
 252             batch.AddExportedValue("Single", typeof(Single), (int)10);\r
 253 \r
 254             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 255                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport,\r
 256                                           RetryMode.DoNotRetry, () =>\r
 257             {\r
 258                 container.Compose(batch);\r
 259             });\r
 260         }\r
 261 \r
 262         [TestMethod]\r
 263         public void MemberExports()\r
 264         {\r
 265             var exporter = PartFactory.CreateAttributed(new ObjectWithMemberExports());\r
 266             var container = ContainerFactory.Create();\r
 267             CompositionBatch batch = new CompositionBatch();\r
 268             batch.AddPart(exporter);\r
 269             container.Compose(batch);\r
 270 \r
 271             var filedExports = container.GetExports<int>("field");\r
 272             ExportsAssert.AreEqual(filedExports, 1, 5);\r
 273 \r
 274             var readonlyExports = container.GetExports<int>("readonly");\r
 275             ExportsAssert.AreEqual(readonlyExports, 2, 6);\r
 276 \r
 277             var propertyExports = container.GetExports<int>("property");\r
 278             ExportsAssert.AreEqual(propertyExports, 3, 7);\r
 279 \r
 280             var methodExports = container.GetExportedValues<Func<int, int>>("func").Select(f => f(0));\r
 281             EnumerableAssert.AreEqual(methodExports, 4, 8);\r
 282         }\r
 283 \r
 284         [TestMethod]\r
 285         public void TestExportedValueCachesValue()\r
 286         {\r
 287             var container = ContainerFactory.Create();\r
 288             var exporter = new ExportsMutableProperty();\r
 289             exporter.Property = "Value1";\r
 290 \r
 291             container.ComposeParts(exporter);\r
 292 \r
 293             Assert.AreEqual("Value1", container.GetExportedValue<string>("Property"));\r
 294 \r
 295             exporter.Property = "Value2";\r
 296 \r
 297             //  Exported value should have been cached and so it shouldn't change\r
 298             Assert.AreEqual("Value1", container.GetExportedValue<string>("Property"));\r
 299         }\r
 300 \r
 301         [TestMethod]\r
 302         [WorkItem(739354)]\r
 303         [Ignore]\r
 304         public void TestExportedValueCachesNullValue()\r
 305         {\r
 306             var container = ContainerFactory.Create();\r
 307             var exporter = new ExportsMutableProperty();\r
 308             exporter.Property = null;\r
 309 \r
 310             container.ComposeParts(exporter);\r
 311 \r
 312             Assert.IsNull(container.GetExportedValue<string>("Property"));\r
 313 \r
 314             exporter.Property = "Value1";\r
 315 \r
 316             //  Exported value should have been cached and so it shouldn't change\r
 317             Assert.IsNull(container.GetExportedValue<string>("Property"));\r
 318         }\r
 319 \r
 320         public class ExportsMutableProperty\r
 321         {\r
 322             [Export("Property")]\r
 323             public string Property { get; set; }\r
 324         }\r
 325 \r
 326         public class ReadOnlyFieldImport\r
 327         {\r
 328             [Import("readonly")]\r
 329             public readonly string Value = "Value";\r
 330         }\r
 331 \r
 332         public class ReadOnlyPropertyImport\r
 333         {\r
 334             [Import("readonly")]\r
 335             public string Value\r
 336             {\r
 337                 get { return "Value"; }\r
 338             }\r
 339         }\r
 340 \r
 341         public class WriteOnlyPropertyExport\r
 342         {\r
 343             [Export("writeonly")]\r
 344             public string Value\r
 345             {\r
 346                 set { }\r
 347             }\r
 348         }\r
 349 \r
 350         public class ObjectWithMemberExports\r
 351         {\r
 352             [Export("field")]\r
 353             public static int staticField = 1;\r
 354 \r
 355             [Export("readonly")]\r
 356             public static readonly int staticReadonly = 2;\r
 357 \r
 358             [Export("property")]\r
 359             public static int StaticProperty { get { return 3; } }\r
 360 \r
 361             [Export("func")]\r
 362             public static int StaticMethod(int arg1) { return 4; }\r
 363 \r
 364             [Export("field")]\r
 365             public int instanceField = 5;\r
 366 \r
 367             [Export("readonly")]\r
 368             public readonly int instanceReadonly = 6;\r
 369 \r
 370             [Export("property")]\r
 371             public int InstanceProperty { get { return 7; } }\r
 372 \r
 373             [Export("func")]\r
 374             public int InstanceMethod(int arg1) { return 8; }\r
 375         }\r
 376 \r
 377         public class HasOnlyStaticExports\r
 378         {\r
 379             public static bool InstanceCreated;\r
 380 \r
 381             public HasOnlyStaticExports()\r
 382             {\r
 383                 InstanceCreated = true;\r
 384             }\r
 385 \r
 386             [Export("Field")]\r
 387             public static string Field = "Field";\r
 388 \r
 389             [Export("Property")]\r
 390             public static string Property\r
 391             {\r
 392                 get { return "Property"; }\r
 393             }\r
 394 \r
 395             [Export("Method")]\r
 396             public static string Method()\r
 397             {\r
 398                 return "Method";\r
 399             }\r
 400         }\r
 401 \r
 402         [InheritedExport(typeof(Base))]\r
 403         public abstract class Base\r
 404         {\r
 405         }\r
 406 \r
 407         [Export(typeof(Derived))]\r
 408         public class Derived : Base\r
 409         {\r
 410         }\r
 411 \r
 412         public class ImportValueTypes\r
 413         {\r
 414             [Import("Int16", AllowDefault = true)]\r
 415             public short Int16\r
 416             {\r
 417                 get;\r
 418                 set;\r
 419             }\r
 420 \r
 421             [Import("Int32", AllowDefault = true)]\r
 422             public int Int32\r
 423             {\r
 424                 get;\r
 425                 set;\r
 426             }\r
 427 \r
 428             [Import("UInt32", AllowDefault = true)]\r
 429             [CLSCompliant(false)]\r
 430             public uint UInt32\r
 431             {\r
 432                 get;\r
 433                 set;\r
 434             }\r
 435 \r
 436             [Import("Int64", AllowDefault = true)]\r
 437             public long Int64\r
 438             {\r
 439                 get;\r
 440                 set;\r
 441             }\r
 442 \r
 443             [Import("Single", AllowDefault = true)]\r
 444             public float Single\r
 445             {\r
 446                 get;\r
 447                 set;\r
 448             }\r
 449 \r
 450             [Import("Double", AllowDefault = true)]\r
 451             public double Double\r
 452             {\r
 453                 get;\r
 454                 set;\r
 455             }\r
 456 \r
 457             [Import("DateTime", AllowDefault = true)]\r
 458             public DateTime DateTime\r
 459             {\r
 460                 get;\r
 461                 set;\r
 462             }\r
 463         }\r
 464     }\r
 465 }\r