ScopeExportFactoryTests

From Testing, 3 Months ago, written in C#, viewed 48 times. This paste will bite the big one in 1 Second.
URL http://codebin.org/view/4b8266f5 Embed
Download Paste or View Raw
  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. // See the LICENSE file in the project root for more information.
  4.  
  5. using System.ComponentModel.Composition.Hosting;
  6. using System.ComponentModel.Composition.Primitives;
  7. using Xunit;
  8.  
  9. namespace System.ComponentModel.Composition
  10. {
  11.     public class ScopeExportFactoryTests
  12.     {
  13.         public interface IFooContract
  14.         {
  15.         }
  16.  
  17.         public interface IFooMetadata
  18.         {
  19.             string Name { get; }
  20.         }
  21.  
  22.         public interface IBarContract
  23.         {
  24.             IFooContract CreateFoo();
  25.         }
  26.  
  27.         public interface IBlahContract
  28.         {
  29.         }
  30.  
  31.         [Export(typeof(IFooContract))]
  32.         [ExportMetadata("Name", "Foo")]
  33.         public class FooImpl : IFooContract
  34.         {
  35.         }
  36.  
  37.         [Export(typeof(IFooContract))]
  38.         [ExportMetadata("Name", "Foo")]
  39.         public class Foo2Impl : IFooContract
  40.         {
  41.         }
  42.  
  43.         [Export(typeof(IFooContract))]
  44.         public class Foo3Impl : IFooContract
  45.         {
  46.             [Import]
  47.             public IBlahContract Blah { get; set; }
  48.         }
  49.  
  50.         [Export(typeof(IFooContract))]
  51.         public class Foo4Impl : IFooContract
  52.         {
  53.             [Import]
  54.             public ExportFactory<IFooContract> Blah { get; set; }
  55.         }
  56.  
  57.         [Export(typeof(IBlahContract))]
  58.         public class BlahImpl : IBlahContract
  59.         {
  60.             [Import]
  61.             public IBlahContract Blah { get; set; }
  62.         }
  63.  
  64.         [Export(typeof(IBarContract))]
  65.         public class BarImpl : IBarContract
  66.         {
  67.             [Import]
  68.             public ExportFactory<IFooContract> FooFactory { get; set; }
  69.  
  70.             public IFooContract CreateFoo()
  71.             {
  72.                 var efv = this.FooFactory.CreateExport();
  73.                 var value = efv.Value;
  74.                 efv.Dispose();
  75.                 return value;
  76.             }
  77.         }
  78.  
  79.         [Export(typeof(IBarContract))]
  80.         public class BarWithMany : IBarContract
  81.         {
  82.             [ImportMany]
  83.             public ExportFactory<IFooContract>[] FooFactories { get; set; }
  84.  
  85.             public IFooContract CreateFoo()
  86.             {
  87.                 var efv = this.FooFactories[0].CreateExport();
  88.                 var value = efv.Value;
  89.                 efv.Dispose();
  90.                 return value;
  91.             }
  92.         }
  93.  
  94.         [Export(typeof(IBarContract))]
  95.         public class BarImplWithMetadata : IBarContract
  96.         {
  97.             [Import]
  98.             public ExportFactory<IFooContract, IFooMetadata> FooFactory { get; set; }
  99.  
  100.             public IFooContract CreateFoo()
  101.             {
  102.                 Assert.Equal("Foo", this.FooFactory.Metadata.Name);
  103.                 var efv = this.FooFactory.CreateExport();
  104.                 var value = efv.Value;
  105.                 efv.Dispose();
  106.                 return value;
  107.             }
  108.         }
  109.  
  110.         [Fact]
  111.         public void SimpleChain()
  112.         {
  113.             var parentCatalog = new TypeCatalog(typeof(BarImpl));
  114.             var childCatalog = new TypeCatalog(typeof(FooImpl));
  115.  
  116.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  117.             var container = new CompositionContainer(scope);
  118.  
  119.             var bar = container.GetExportedValue<IBarContract>();
  120.             Assert.NotNull(bar);
  121.  
  122.             var foo1 = bar.CreateFoo();
  123.             Assert.NotNull(foo1);
  124.             Assert.True(foo1 is FooImpl);
  125.  
  126.             var foo2 = bar.CreateFoo();
  127.             Assert.NotNull(foo1);
  128.             Assert.True(foo2 is FooImpl);
  129.  
  130.             Assert.NotEqual(foo1, foo2);
  131.         }
  132.  
  133.         [Fact]
  134.         public void SimpleChainWithTwoChildren()
  135.         {
  136.             var parentCatalog = new TypeCatalog(typeof(BarWithMany));
  137.             var childCatalog1 = new TypeCatalog(typeof(FooImpl));
  138.             var childCatalog2 = new TypeCatalog(typeof(Foo2Impl));
  139.  
  140.             var scope = parentCatalog.AsScope(childCatalog1.AsScope(), childCatalog2.AsScope());
  141.             var container = new CompositionContainer(scope);
  142.  
  143.             var bar = container.GetExportedValue<IBarContract>() as BarWithMany;
  144.             Assert.NotNull(bar);
  145.  
  146.             Assert.Equal(2, bar.FooFactories.Length);
  147.  
  148.             IFooContract foo1 = null;
  149.             using (var efFoo1 = bar.FooFactories[0].CreateExport())
  150.             {
  151.                 foo1 = efFoo1.Value;
  152.             }
  153.  
  154.             IFooContract foo2 = null;
  155.             using (var efFoo2 = bar.FooFactories[1].CreateExport())
  156.             {
  157.                 foo2 = efFoo2.Value;
  158.             }
  159.  
  160.             Assert.True(((foo1 is FooImpl) && (foo2 is Foo2Impl)) || ((foo2 is FooImpl) && (foo1 is Foo2Impl)));
  161.         }
  162.  
  163.         [Fact]
  164.         public void SimpleChainWithMetadata()
  165.         {
  166.             var parentCatalog = new TypeCatalog(typeof(BarImplWithMetadata));
  167.             var childCatalog = new TypeCatalog(typeof(FooImpl));
  168.  
  169.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  170.             var container = new CompositionContainer(scope);
  171.  
  172.             var bar = container.GetExportedValue<IBarContract>();
  173.             Assert.NotNull(bar);
  174.  
  175.             var foo1 = bar.CreateFoo();
  176.             Assert.NotNull(foo1);
  177.             Assert.True(foo1 is FooImpl);
  178.  
  179.             var foo2 = bar.CreateFoo();
  180.             Assert.NotNull(foo1);
  181.             Assert.True(foo2 is FooImpl);
  182.  
  183.             Assert.NotEqual(foo1, foo2);
  184.         }
  185.  
  186.         [Fact]
  187.         public void SimpleChainWithLowerLoop()
  188.         {
  189.             var parentCatalog = new TypeCatalog(typeof(BarImpl));
  190.             var childCatalog = new TypeCatalog(typeof(Foo3Impl), typeof(BlahImpl));
  191.  
  192.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  193.             var container = new CompositionContainer(scope);
  194.  
  195.             var bar = container.GetExportedValue<IBarContract>();
  196.             Assert.NotNull(bar);
  197.  
  198.             var foo1 = bar.CreateFoo();
  199.             Assert.NotNull(foo1);
  200.             Assert.True(foo1 is Foo3Impl);
  201.  
  202.             var foo2 = bar.CreateFoo();
  203.             Assert.NotNull(foo1);
  204.             Assert.True(foo2 is Foo3Impl);
  205.  
  206.             Assert.NotEqual(foo1, foo2);
  207.         }
  208.  
  209.         [Fact]
  210.         public void SimpleChainWithCrossLoop()
  211.         {
  212.             var parentCatalog = new TypeCatalog(typeof(BarImpl));
  213.             var childCatalog = new TypeCatalog(typeof(Foo4Impl));
  214.  
  215.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  216.             var container = new CompositionContainer(scope);
  217.  
  218.             var bar = container.GetExportedValue<IBarContract>();
  219.             Assert.NotNull(bar);
  220.  
  221.             var foo1 = bar.CreateFoo();
  222.             Assert.NotNull(foo1);
  223.             Assert.True(foo1 is Foo4Impl);
  224.  
  225.             var foo2 = bar.CreateFoo();
  226.             Assert.NotNull(foo1);
  227.             Assert.True(foo2 is Foo4Impl);
  228.  
  229.             Assert.NotEqual(foo1, foo2);
  230.         }
  231.  
  232.         [Fact]
  233.         public void SimpleChainWithLowerLoopRejection()
  234.         {
  235.             var parentCatalog = new TypeCatalog(typeof(BarImpl));
  236.             var childCatalog = new TypeCatalog(typeof(Foo3Impl));
  237.  
  238.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  239.             var container = new CompositionContainer(scope);
  240.  
  241.             var bar = container.GetExportedValueOrDefault<IBarContract>();
  242.             Assert.Null(bar);
  243.         }
  244.  
  245.         [Fact]
  246.         public void ExportFactoryCausesRejectionBasedOnContract()
  247.         {
  248.             var parentCatalog = new TypeCatalog(typeof(BarImpl));
  249.             var childCatalog = new TypeCatalog(typeof(BarImpl));
  250.  
  251.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  252.             var container = new CompositionContainer(scope);
  253.  
  254.             var bar = container.GetExportedValueOrDefault<IBarContract>();
  255.             Assert.Null(bar);
  256.         }
  257.  
  258.         [Fact]
  259.         public void ExportFactoryCausesRejectionBasedOnCardinality()
  260.         {
  261.             var parentCatalog = new TypeCatalog(typeof(BarImpl));
  262.             var childCatalog = new TypeCatalog(typeof(FooImpl), typeof(Foo2Impl));
  263.  
  264.             var scope = parentCatalog.AsScope(childCatalog.AsScope());
  265.             var container = new CompositionContainer(scope);
  266.  
  267.             var bar = container.GetExportedValueOrDefault<IBarContract>();
  268.             Assert.Null(bar);
  269.         }
  270.     }
  271.  
  272.     public class ScopeExportFactoryWithPublicSurface
  273.     {
  274.         [Export] public class ClassA { }
  275.  
  276.         [Export] public class ClassB { }
  277.  
  278.         [Export] public class ClassC { }
  279.  
  280.         [Export]
  281.         public class ClassRoot
  282.         {
  283.             [ImportAttribute]
  284.             public ExportFactory<ClassA> classA;
  285.  
  286.             [ImportAttribute]
  287.             public ExportFactory<ClassB> classB;
  288.  
  289.             [ImportAttribute]
  290.             public ExportFactory<ClassB> classC;
  291.         }
  292.  
  293.         [Fact]
  294.         public void FilteredScopeFactoryOfTM_ShouldSucceed()
  295.         {
  296.             var c1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA));
  297.             var c2 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC));
  298.             var c3 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC));
  299.             var c4 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC));
  300.             var sd = c1.AsScope(c2.AsScopeWithPublicSurface<ClassA>(),
  301.                                 c3.AsScopeWithPublicSurface<ClassB>(),
  302.                                 c4.AsScopeWithPublicSurface<ClassC>());
  303.  
  304.             var container = new CompositionContainer(sd);
  305.  
  306.             var fromRoot = container.GetExportedValue<ClassRoot>();
  307.             var a = fromRoot.classA.CreateExport().Value;
  308.             var b = fromRoot.classB.CreateExport().Value;
  309.             var c = fromRoot.classC.CreateExport().Value;
  310.  
  311.         }
  312.     }
  313.  
  314.     public class ScopeFactoryAutoResolveFromAncestorScope
  315.     {
  316.         [Export] public class Root { }
  317.  
  318.         [Export] public class Child { }
  319.  
  320.         [Export]
  321.         public class ClassRoot
  322.         {
  323.             [ImportAttribute]
  324.             public ExportFactory<ClassA> classA;
  325.  
  326.             [ImportAttribute]
  327.             public ClassA localClassA;
  328.         }
  329.  
  330.         [Export]
  331.         public class ClassA
  332.         {
  333.             [Import]
  334.             public ICompositionService CompositionService;
  335.  
  336.             [ImportAttribute]
  337.             public Root classRoot;
  338.  
  339.             public int InstanceValue;
  340.         }
  341.  
  342.         public class ImportA
  343.         {
  344.             [Import]
  345.             public ClassA classA;
  346.         }
  347.  
  348.         [Fact]
  349.         public void ScopeFactoryAutoResolveFromAncestorScopeShouldSucceed()
  350.         {
  351.             var c1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA), typeof(Root));
  352.             var c2 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA), typeof(Child));
  353.             var sd = c1.AsScope(c2.AsScope());
  354.  
  355.             var container = new CompositionContainer(sd, CompositionOptions.ExportCompositionService);
  356.  
  357.             var fromRoot = container.GetExportedValue<ClassRoot>();
  358.             var a1 = fromRoot.classA.CreateExport().Value;
  359.             var a2 = fromRoot.classA.CreateExport().Value;
  360.             fromRoot.localClassA.InstanceValue = 101;
  361.             a1.InstanceValue = 202;
  362.             a2.InstanceValue = 303;
  363.  
  364.             Assert.NotEqual(a1.InstanceValue, a2.InstanceValue);
  365.             Assert.NotNull(fromRoot.localClassA.classRoot);
  366.             Assert.NotNull(a1.classRoot);
  367.             Assert.NotNull(a2.classRoot);
  368.         }
  369.     }
  370.  
  371.     public class DeeplyNestedCatalog
  372.     {
  373.         [Export]
  374.         public class ClassRoot
  375.         {
  376.             [ImportAttribute]
  377.             public ExportFactory<ClassA> classA;
  378.         }
  379.  
  380.         [Export]
  381.         public class ClassA
  382.         {
  383.             [ImportAttribute]
  384.             public ExportFactory<ClassB> classB;
  385.         }
  386.  
  387.         [Export]
  388.         public class ClassB
  389.         {
  390.             [ImportAttribute]
  391.             public ExportFactory<ClassC> classC;
  392.  
  393.             public int InstanceValue;
  394.         }
  395.  
  396.         [Export]
  397.         public class ClassC
  398.         {
  399.             [ImportAttribute]
  400.             public ExportFactory<ClassD> classD;
  401.         }
  402.  
  403.         [Export]
  404.         public class ClassD
  405.         {
  406.         }
  407.  
  408.         [Fact]
  409.         public void DeeplyNestedCatalogPartitionedCatalog_ShouldWork()
  410.         {
  411.             var cat1 = new TypeCatalog(typeof(ClassRoot));
  412.             var cat2 = new TypeCatalog(typeof(ClassA));
  413.             var cat3 = new TypeCatalog(typeof(ClassB));
  414.             var cat4 = new TypeCatalog(typeof(ClassC));
  415.             var cat5 = new TypeCatalog(typeof(ClassD));
  416.             var sd = cat1.AsScope(cat2.AsScope(cat3.AsScope(cat4.AsScope(cat5.AsScope()))));
  417.  
  418.             var container = new CompositionContainer(sd);
  419.  
  420.             var fromRoot = container.GetExportedValue<ClassRoot>();
  421.  
  422.             var a1 = fromRoot.classA.CreateExport().Value;
  423.             var b1 = a1.classB.CreateExport().Value;
  424.             var c1 = b1.classC.CreateExport().Value;
  425.             var d1 = c1.classD.CreateExport().Value;
  426.         }
  427.  
  428.         [Fact]
  429.         public void DeeplyNestedCatalogOverlappedCatalog_ShouldWork()
  430.         {
  431.             var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassA), typeof(ClassB), typeof(ClassC), typeof(ClassD));
  432.             var cat2 = cat1;
  433.             var cat3 = cat1;
  434.             var cat4 = cat1;
  435.             var cat5 = cat1;
  436.             var sd = cat1.AsScope(cat2.AsScope(cat3.AsScope(cat4.AsScope(cat5.AsScope()))));
  437.  
  438.             var container = new CompositionContainer(sd);
  439.  
  440.             var fromRoot = container.GetExportedValue<ClassRoot>();
  441.  
  442.             var a1 = fromRoot.classA.CreateExport().Value;
  443.             var b1 = a1.classB.CreateExport().Value;
  444.             var c1 = b1.classC.CreateExport().Value;
  445.             var d1 = c1.classD.CreateExport().Value;
  446.         }
  447.     }
  448.  
  449.     public class LocalSharedNonLocalInSameContainer
  450.     {
  451.         [Export]
  452.         public class ClassRoot
  453.         {
  454.             [ImportAttribute]
  455.             public ExportFactory<ClassA> classA;
  456.  
  457.             [ImportAttribute]
  458.             public ClassXXXX xxxx;
  459.         }
  460.  
  461.         [Export]
  462.         public class ClassA
  463.         {
  464.             [ImportAttribute]
  465.             public ExportFactory<ClassB> classB;
  466.  
  467.             [ImportAttribute]
  468.             public ClassXXXX xxxx;
  469.         }
  470.  
  471.         [Export]
  472.         public class ClassB
  473.         {
  474.             [ImportAttribute]
  475.             public ExportFactory<ClassC> classC;
  476.  
  477.             [ImportAttribute]
  478.             public ClassXXXX xxxx;
  479.         }
  480.  
  481.         [Export]
  482.         public class ClassC
  483.         {
  484.             [ImportAttribute(Source = ImportSource.NonLocal)]
  485.             public ClassXXXX xxxx;
  486.  
  487.             [Import]
  488.             public ClassD classD;
  489.         }
  490.  
  491.         [Export]
  492.         public class ClassD
  493.         {
  494.             [ImportAttribute]
  495.             public ClassXXXX xxxx;
  496.         }
  497.  
  498.         [Export]
  499.         public class ClassXXXX
  500.         {
  501.             public int InstanceValue;
  502.         }
  503.  
  504.         [Fact]
  505.         public void LocalSharedNonLocalInSameContainer_ShouldSucceed()
  506.         {
  507.             var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassXXXX));
  508.             var cat2 = new TypeCatalog(typeof(ClassA));
  509.             var cat3 = new TypeCatalog(typeof(ClassB));
  510.             var cat4 = new TypeCatalog(typeof(ClassC), typeof(ClassD), typeof(ClassXXXX));
  511.             var sd = cat1.AsScope(cat2.AsScope(cat3.AsScope(cat4.AsScope())));
  512.  
  513.             var container = new CompositionContainer(sd);
  514.  
  515.             var fromRoot = container.GetExportedValue<ClassRoot>();
  516.             var a1 = fromRoot.classA.CreateExport().Value;
  517.             fromRoot.xxxx.InstanceValue = 16;
  518.             var b1 = a1.classB.CreateExport().Value;
  519.             var c1 = b1.classC.CreateExport().Value;
  520.  
  521.             Assert.Equal(16, fromRoot.xxxx.InstanceValue);
  522.             Assert.Equal(16, a1.xxxx.InstanceValue);
  523.             Assert.Equal(16, b1.xxxx.InstanceValue);
  524.             Assert.Equal(16, c1.xxxx.InstanceValue);
  525.             Assert.Equal(0, c1.classD.xxxx.InstanceValue);
  526.  
  527.             c1.xxxx.InstanceValue = 8;
  528.  
  529.             Assert.Equal(8, fromRoot.xxxx.InstanceValue);
  530.             Assert.Equal(8, a1.xxxx.InstanceValue);
  531.             Assert.Equal(8, b1.xxxx.InstanceValue);
  532.             Assert.Equal(8, c1.xxxx.InstanceValue);
  533.             Assert.Equal(0, c1.classD.xxxx.InstanceValue);
  534.  
  535.             c1.classD.xxxx.InstanceValue = 2;
  536.             Assert.Equal(8, fromRoot.xxxx.InstanceValue);
  537.             Assert.Equal(8, a1.xxxx.InstanceValue);
  538.             Assert.Equal(8, b1.xxxx.InstanceValue);
  539.             Assert.Equal(8, c1.xxxx.InstanceValue);
  540.             Assert.Equal(2, c1.classD.xxxx.InstanceValue);
  541.  
  542.         }
  543.     }
  544.  
  545.     public class ScopeBridgingAdaptersConstructorInjection
  546.     {
  547.         [Export]
  548.         public class ClassRoot
  549.         {
  550.             [ImportAttribute]
  551.             public ExportFactory<ClassC> classC;
  552.  
  553.             [ImportAttribute]
  554.             public ClassXXXX xxxx;
  555.         }
  556.  
  557.         [Export]
  558.         public class ClassC
  559.         {
  560.             [ImportingConstructor]
  561.             public ClassC([ImportAttribute(RequiredCreationPolicy = CreationPolicy.NonShared, Source = ImportSource.NonLocal)]ClassXXXX xxxx)
  562.             {
  563.                 this.xxxx = xxxx;
  564.             }
  565.  
  566.             [Export]
  567.             public ClassXXXX xxxx;
  568.  
  569.             [Import]
  570.             public ClassD classD;
  571.         }
  572.  
  573.         [Export]
  574.         public class ClassD
  575.         {
  576.             [Import]
  577.             public ClassXXXX xxxx;
  578.         }
  579.  
  580.         [Export]
  581.         public class ClassXXXX
  582.         {
  583.             public int InstanceValue;
  584.         }
  585.  
  586.         [Fact]
  587.         public void ScopeBridgingAdapters_ShouldSucceed()
  588.         {
  589.             var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassXXXX));
  590.             var cat2 = new TypeCatalog(typeof(ClassC), typeof(ClassD));
  591.             var sd = cat1.AsScope(cat2.AsScope());
  592.             var container = new CompositionContainer(sd);
  593.  
  594.             var fromRoot = container.GetExportedValue<ClassRoot>();
  595.             var c1 = fromRoot.classC.CreateExport().Value;
  596.             var c2 = fromRoot.classC.CreateExport().Value;
  597.             var c3 = fromRoot.classC.CreateExport().Value;
  598.             var c4 = fromRoot.classC.CreateExport().Value;
  599.             var c5 = fromRoot.classC.CreateExport().Value;
  600.  
  601.             Assert.Equal(0, fromRoot.xxxx.InstanceValue);
  602.             Assert.Equal(0, c1.xxxx.InstanceValue);
  603.             Assert.Equal(0, c1.classD.xxxx.InstanceValue);
  604.             Assert.Equal(0, c2.xxxx.InstanceValue);
  605.             Assert.Equal(0, c2.classD.xxxx.InstanceValue);
  606.             Assert.Equal(0, c3.xxxx.InstanceValue);
  607.             Assert.Equal(0, c3.classD.xxxx.InstanceValue);
  608.             Assert.Equal(0, c4.xxxx.InstanceValue);
  609.             Assert.Equal(0, c4.classD.xxxx.InstanceValue);
  610.             Assert.Equal(0, c5.xxxx.InstanceValue);
  611.             Assert.Equal(0, c5.classD.xxxx.InstanceValue);
  612.  
  613.             c1.xxxx.InstanceValue = 1;
  614.             c2.xxxx.InstanceValue = 2;
  615.             c3.xxxx.InstanceValue = 3;
  616.             c4.xxxx.InstanceValue = 4;
  617.             c5.xxxx.InstanceValue = 5;
  618.  
  619.             Assert.Equal(0, fromRoot.xxxx.InstanceValue);
  620.             Assert.Equal(1, c1.xxxx.InstanceValue);
  621.             Assert.Equal(1, c1.classD.xxxx.InstanceValue);
  622.             Assert.Equal(2, c2.xxxx.InstanceValue);
  623.             Assert.Equal(2, c2.classD.xxxx.InstanceValue);
  624.             Assert.Equal(3, c3.xxxx.InstanceValue);
  625.             Assert.Equal(3, c3.classD.xxxx.InstanceValue);
  626.             Assert.Equal(4, c4.xxxx.InstanceValue);
  627.             Assert.Equal(4, c4.classD.xxxx.InstanceValue);
  628.             Assert.Equal(5, c5.xxxx.InstanceValue);
  629.             Assert.Equal(5, c5.classD.xxxx.InstanceValue);
  630.         }
  631.     }
  632.  
  633.     public class ScopeBridgingAdaptersImportExportProperty
  634.     {
  635.         [Export]
  636.         public class ClassRoot
  637.         {
  638.             [ImportAttribute]
  639.             public ExportFactory<ClassC> classC;
  640.  
  641.             [ImportAttribute]
  642.             public ClassXXXX xxxx;
  643.         }
  644.  
  645.         [Export]
  646.         public class ClassC
  647.         {
  648.             [Export]
  649.             [ImportAttribute(RequiredCreationPolicy = CreationPolicy.NonShared, Source = ImportSource.NonLocal)]
  650.             public ClassXXXX xxxx;
  651.  
  652.             [Import]
  653.             public ClassD classD;
  654.         }
  655.  
  656.         [Export]
  657.         public class ClassD
  658.         {
  659.             [Import]
  660.             public ClassXXXX xxxx;
  661.         }
  662.  
  663.         [Export]
  664.         public class ClassXXXX
  665.         {
  666.             public int InstanceValue;
  667.         }
  668.  
  669.         [Fact]
  670.         public void ScopeBridgingAdaptersImportExportProperty_ShouldSucceed()
  671.         {
  672.             var cat1 = new TypeCatalog(typeof(ClassRoot), typeof(ClassXXXX));
  673.             var cat2 = new TypeCatalog(typeof(ClassC), typeof(ClassD));
  674.             var sd = cat1.AsScope(cat2.AsScope());
  675.             var container = new CompositionContainer(sd);
  676.  
  677.             var fromRoot = container.GetExportedValue<ClassRoot>();
  678.             var c1 = fromRoot.classC.CreateExport().Value;
  679.             var c2 = fromRoot.classC.CreateExport().Value;
  680.             var c3 = fromRoot.classC.CreateExport().Value;
  681.             var c4 = fromRoot.classC.CreateExport().Value;
  682.             var c5 = fromRoot.classC.CreateExport().Value;
  683.  
  684.             Assert.Equal(0, fromRoot.xxxx.InstanceValue);
  685.             Assert.Equal(0, c1.xxxx.InstanceValue);
  686.             Assert.Equal(0, c1.classD.xxxx.InstanceValue);
  687.             Assert.Equal(0, c2.xxxx.InstanceValue);
  688.             Assert.Equal(0, c2.classD.xxxx.InstanceValue);
  689.             Assert.Equal(0, c3.xxxx.InstanceValue);
  690.             Assert.Equal(0, c3.classD.xxxx.InstanceValue);
  691.             Assert.Equal(0, c4.xxxx.InstanceValue);
  692.             Assert.Equal(0, c4.classD.xxxx.InstanceValue);
  693.             Assert.Equal(0, c5.xxxx.InstanceValue);
  694.             Assert.Equal(0, c5.classD.xxxx.InstanceValue);
  695.  
  696.             c1.xxxx.InstanceValue = 1;
  697.             c2.xxxx.InstanceValue = 2;
  698.             c3.xxxx.InstanceValue = 3;
  699.             c4.xxxx.InstanceValue = 4;
  700.             c5.xxxx.InstanceValue = 5;
  701.  
  702.             Assert.Equal(0, fromRoot.xxxx.InstanceValue);
  703.             Assert.Equal(1, c1.xxxx.InstanceValue);
  704.             Assert.Equal(1, c1.classD.xxxx.InstanceValue);
  705.             Assert.Equal(2, c2.xxxx.InstanceValue);
  706.             Assert.Equal(2, c2.classD.xxxx.InstanceValue);
  707.             Assert.Equal(3, c3.xxxx.InstanceValue);
  708.             Assert.Equal(3, c3.classD.xxxx.InstanceValue);
  709.             Assert.Equal(4, c4.xxxx.InstanceValue);
  710.             Assert.Equal(4, c4.classD.xxxx.InstanceValue);
  711.             Assert.Equal(5, c5.xxxx.InstanceValue);
  712.             Assert.Equal(5, c5.classD.xxxx.InstanceValue);
  713.         }
  714.     }
  715.  
  716.     public class SelfExportFromExportFactory
  717.     {
  718.         [Export]
  719.         public class ClassRoot
  720.         {
  721.             [ImportAttribute]
  722.             public ExportFactory<ClassA> classA;
  723.         }
  724.  
  725.         [Export]
  726.         public class ClassA
  727.         {
  728.             [ImportAttribute] public ClassB classB;
  729.             [ImportAttribute] public ClassC classC;
  730.             [ImportAttribute] public ClassD classD;
  731.  
  732.             public int InstanceValue;
  733.         }
  734.  
  735.         [Export]
  736.         public class ClassB
  737.         {
  738.             [ImportAttribute] public ClassA classA;
  739.         }
  740.  
  741.         [Export]
  742.         public class ClassC
  743.         {
  744.             [ImportAttribute] public ClassA classA;
  745.         }
  746.  
  747.         [Export]
  748.         public class ClassD
  749.         {
  750.             [ImportAttribute] public ClassA classA;
  751.         }
  752.  
  753.         [Fact]
  754.         public void SelfExportFromExportFactory_ShouldSucceed()
  755.         {
  756.             var cat1 = new TypeCatalog(typeof(ClassRoot));
  757.             var cat2 = new TypeCatalog(typeof(ClassA), typeof(ClassB), typeof(ClassC), typeof(ClassD));
  758.             var sd = cat1.AsScope(cat2.AsScope());
  759.  
  760.             var container = new CompositionContainer(sd);
  761.  
  762.             var fromRoot = container.GetExportedValue<ClassRoot>();
  763.             var a1 = fromRoot.classA.CreateExport().Value;
  764.  
  765.             a1.InstanceValue = 8;
  766.  
  767.             Assert.Equal(8, a1.classB.classA.InstanceValue);
  768.             Assert.Equal(8, a1.classC.classA.InstanceValue);
  769.             Assert.Equal(8, a1.classD.classA.InstanceValue);
  770.         }
  771.     }
  772. }
  773.  

Reply to "ScopeExportFactoryTests"

Here you can reply to the paste above