review.tizen.org Git - platform/upstream/dotnet/runtime.git/blob

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3
   4 using System.Collections.Generic;
   5 using System.ComponentModel.Composition.Factories;
   6 using System.ComponentModel.Composition.Primitives;
   7 using Xunit;
   8
   9 namespace System.ComponentModel.Composition.AttributedModel
  10 {
  11     class ConcreteCPD : ComposablePartDefinition
  12     {
  13         public override ComposablePart CreatePart()
  14         {
  15             throw new NotImplementedException();
  16         }
  17
  18         public override IEnumerable<ExportDefinition> ExportDefinitions
  19         {
  20             get { throw new NotImplementedException(); }
  21         }
  22
  23         public override IEnumerable<ImportDefinition> ImportDefinitions
  24         {
  25             get { throw new NotImplementedException(); }
  26         }
  27     }
  28
  29     public class CPDTest { }
  30
  31     public class AttributedModelServicesTests
  32     {
  33         [Fact]
  34         public void CreatePartDefinition1_NullAsType_ShouldThrowArgumentNull()
  35         {
  36             var origin = ElementFactory.Create();
  37
  38             Assert.Throws<ArgumentNullException>("type", () =>
  39             {
  40                 AttributedModelServices.CreatePartDefinition((Type)null, origin);
  41             });
  42         }
  43
  44         [Fact]
  45         public void CreatePartDefinition2_NullAsType_ShouldThrowArgumentNull()
  46         {
  47             var origin = ElementFactory.Create();
  48
  49             Assert.Throws<ArgumentNullException>("type", () =>
  50             {
  51                 AttributedModelServices.CreatePartDefinition((Type)null, origin, false);
  52             });
  53         }
  54
  55         [Fact]
  56         public void CreatePart_From_InvalidPartDefiniton_ShouldThrowArgumentException()
  57         {
  58             Assert.Throws<ArgumentException>("partDefinition", () =>
  59             {
  60                 var partDefinition = new ConcreteCPD();
  61                 var instance = new CPDTest();
  62                 AttributedModelServices.CreatePart(partDefinition, instance);
  63             });
  64         }
  65
  66         [Fact]
  67         public void Exports_Throws_OnNullPart()
  68         {
  69             ComposablePartDefinition part = null;
  70             Type contractType = typeof(IContract1);
  71             Assert.Throws<ArgumentNullException>("part", () =>
  72             {
  73                 part.Exports(contractType);
  74             });
  75         }
  76
  77         [Fact]
  78         public void Exports_Throws_OnNullContractType()
  79         {
  80             ComposablePartDefinition part = typeof(PartExportingContract1).AsPart();
  81             Type contractType = null;
  82             Assert.Throws<ArgumentNullException>("contractType", () =>
  83             {
  84                 part.Exports(contractType);
  85             });
  86         }
  87
  88         [Fact]
  89         public void Exports()
  90         {
  91             ComposablePartDefinition part1 = typeof(PartExportingContract1).AsPart();
  92             ComposablePartDefinition part2 = typeof(PartExportingContract2).AsPart();
  93
  94             Assert.True(part1.Exports(typeof(IContract1)));
  95             Assert.True(part2.Exports(typeof(IContract2)));
  96
  97             Assert.False(part2.Exports(typeof(IContract1)));
  98             Assert.False(part1.Exports(typeof(IContract2)));
  99         }
 100
 101         [Fact]
 102         public void ExportsGeneric_Throws_OnNullPart()
 103         {
 104             ComposablePartDefinition part = null;
 105             Assert.Throws<ArgumentNullException>("part", () =>
 106             {
 107                 part.Exports<IContract1>();
 108             });
 109         }
 110
 111         [Fact]
 112         public void ExportsGeneric()
 113         {
 114             ComposablePartDefinition part1 = typeof(PartExportingContract1).AsPart();
 115             ComposablePartDefinition part2 = typeof(PartExportingContract2).AsPart();
 116
 117             Assert.True(part1.Exports<IContract1>());
 118             Assert.True(part2.Exports<IContract2>());
 119
 120             Assert.False(part2.Exports<IContract1>());
 121             Assert.False(part1.Exports<IContract2>());
 122         }
 123
 124         [Fact]
 125         public void Imports_Throws_OnNullPart()
 126         {
 127             ComposablePartDefinition part = null;
 128             Type contractType = typeof(IContract1);
 129             Assert.Throws<ArgumentNullException>("part", () =>
 130             {
 131                 part.Imports(contractType);
 132             });
 133         }
 134
 135         [Fact]
 136         public void Imports_Throws_OnNullContractName()
 137         {
 138             ComposablePartDefinition part = typeof(PartImportingContract1).AsPart();
 139             Type contractType = null;
 140             Assert.Throws<ArgumentNullException>("contractType", () =>
 141             {
 142                 part.Imports(contractType);
 143             });
 144         }
 145
 146         [Fact]
 147         public void Imports()
 148         {
 149             ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
 150             ComposablePartDefinition part2 = typeof(PartImportingContract2).AsPart();
 151
 152             Assert.True(part1.Imports(typeof(IContract1)));
 153             Assert.True(part2.Imports(typeof(IContract2)));
 154
 155             Assert.False(part2.Imports(typeof(IContract1)));
 156             Assert.False(part1.Imports(typeof(IContract2)));
 157         }
 158
 159         [Fact]
 160         public void Imports_CardinalityIgnored_WhenNotSpecified()
 161         {
 162             ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
 163             ComposablePartDefinition part1Multiple = typeof(PartImportingContract1Multiple).AsPart();
 164             ComposablePartDefinition part1Optional = typeof(PartImportingContract1Optionally).AsPart();
 165
 166             Assert.True(part1.Imports(typeof(IContract1)));
 167             Assert.True(part1Optional.Imports(typeof(IContract1)));
 168             Assert.True(part1Multiple.Imports(typeof(IContract1)));
 169         }
 170
 171         [Fact]
 172         public void Imports_CardinalityNotIgnored_WhenSpecified()
 173         {
 174             ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
 175             ComposablePartDefinition part1Multiple = typeof(PartImportingContract1Multiple).AsPart();
 176             ComposablePartDefinition part1Optional = typeof(PartImportingContract1Optionally).AsPart();
 177
 178             Assert.True(part1.Imports(typeof(IContract1), ImportCardinality.ExactlyOne));
 179             Assert.False(part1.Imports(typeof(IContract1), ImportCardinality.ZeroOrMore));
 180             Assert.False(part1.Imports(typeof(IContract1), ImportCardinality.ZeroOrOne));
 181
 182             Assert.False(part1Multiple.Imports(typeof(IContract1), ImportCardinality.ExactlyOne));
 183             Assert.True(part1Multiple.Imports(typeof(IContract1), ImportCardinality.ZeroOrMore));
 184             Assert.False(part1Multiple.Imports(typeof(IContract1), ImportCardinality.ZeroOrOne));
 185
 186             Assert.False(part1Optional.Imports(typeof(IContract1), ImportCardinality.ExactlyOne));
 187             Assert.False(part1Optional.Imports(typeof(IContract1), ImportCardinality.ZeroOrMore));
 188             Assert.True(part1Optional.Imports(typeof(IContract1), ImportCardinality.ZeroOrOne));
 189         }
 190
 191         [Fact]
 192         public void ImportsGeneric_Throws_OnNullPart()
 193         {
 194             ComposablePartDefinition part = null;
 195             Assert.Throws<ArgumentNullException>("part", () =>
 196             {
 197                 part.Imports<IContract1>();
 198             });
 199         }
 200
 201         [Fact]
 202         public void ImportsGeneric()
 203         {
 204             ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
 205             ComposablePartDefinition part2 = typeof(PartImportingContract2).AsPart();
 206
 207             Assert.True(part1.Imports<IContract1>());
 208             Assert.True(part2.Imports<IContract2>());
 209
 210             Assert.False(part2.Imports<IContract1>());
 211             Assert.False(part1.Imports<IContract2>());
 212         }
 213
 214         [Fact]
 215         public void ImportsGeneric_CardinalityIgnored_WhenNotSpecified()
 216         {
 217             ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
 218             ComposablePartDefinition part1Multiple = typeof(PartImportingContract1Multiple).AsPart();
 219             ComposablePartDefinition part1Optional = typeof(PartImportingContract1Optionally).AsPart();
 220
 221             Assert.True(part1.Imports<IContract1>());
 222             Assert.True(part1Optional.Imports<IContract1>());
 223             Assert.True(part1Multiple.Imports<IContract1>());
 224         }
 225
 226         [Fact]
 227         public void ImportsGeneric_CardinalityNotIgnored_WhenSpecified()
 228         {
 229             ComposablePartDefinition part1 = typeof(PartImportingContract1).AsPart();
 230             ComposablePartDefinition part1Multiple = typeof(PartImportingContract1Multiple).AsPart();
 231             ComposablePartDefinition part1Optional = typeof(PartImportingContract1Optionally).AsPart();
 232
 233             Assert.True(part1.Imports<IContract1>(ImportCardinality.ExactlyOne));
 234             Assert.False(part1.Imports<IContract1>(ImportCardinality.ZeroOrMore));
 235             Assert.False(part1.Imports<IContract1>(ImportCardinality.ZeroOrOne));
 236
 237             Assert.False(part1Multiple.Imports<IContract1>(ImportCardinality.ExactlyOne));
 238             Assert.True(part1Multiple.Imports<IContract1>(ImportCardinality.ZeroOrMore));
 239             Assert.False(part1Multiple.Imports<IContract1>(ImportCardinality.ZeroOrOne));
 240
 241             Assert.False(part1Optional.Imports<IContract1>(ImportCardinality.ExactlyOne));
 242             Assert.False(part1Optional.Imports<IContract1>(ImportCardinality.ZeroOrMore));
 243             Assert.True(part1Optional.Imports<IContract1>(ImportCardinality.ZeroOrOne));
 244         }
 245
 246         public interface IContract1
 247         {
 248         }
 249
 250         public interface IContract2
 251         {
 252         }
 253
 254         [Export(typeof(IContract1))]
 255         public class PartExportingContract1 : IContract1
 256         {
 257         }
 258
 259         [Export(typeof(IContract2))]
 260         public class PartExportingContract2 : IContract2
 261         {
 262         }
 263
 264         public class PartImportingContract1
 265         {
 266             [Import]
 267             public IContract1 import;
 268         }
 269
 270         public class PartImportingContract2
 271         {
 272             [Import]
 273             public IContract2 import;
 274         }
 275
 276         public class PartImportingContract1Optionally
 277         {
 278             [Import(AllowDefault = true)]
 279             public IContract1 import;
 280         }
 281
 282         public class PartImportingContract1Multiple
 283         {
 284             [ImportMany]
 285             public IEnumerable<IContract1> import;
 286         }
 287     }
 288 }