InversionOfControl/Castle.Windsor.Tests/DependencyProblem.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Windsor.Tests
  16 {
  17         using NUnit.Framework;
  18
  19         /// <summary>
  20         /// Reported at http://forum.castleproject.org/posts/list/17.page
  21         /// </summary>
  22         [TestFixture]
  23         public class DependencyProblem
  24         {
  25                 private IWindsorContainer container;
  26
  27                 [SetUp]
  28                 public void Init()
  29                 {
  30                         container = new WindsorContainer();
  31                 }
  32
  33                 [Test]
  34                 public void LoadingInSequence()
  35                 {
  36                         container.AddComponent("C", typeof(C));
  37                         container.AddComponent("B", typeof(B));
  38                         container.AddComponent("A", typeof(A));
  39
  40                         Assert.IsNotNull(container["A"]);
  41                         Assert.IsNotNull(container["B"]);
  42                         Assert.IsNotNull(container["C"]);
  43                 }
  44
  45                 [Test]
  46                 public void LoadingPartiallyInSequence()
  47                 {
  48                         container.AddComponent("B", typeof(B));
  49                         container.AddComponent("C", typeof(C));
  50                         container.AddComponent("A", typeof(A));
  51
  52                         Assert.IsNotNull(container["A"]);
  53                         Assert.IsNotNull(container["B"]);
  54                         Assert.IsNotNull(container["C"]);
  55                 }
  56
  57                 [Test]
  58                 public void LoadingOutOfSequence()
  59                 {
  60                         container.AddComponent("A", typeof(A));
  61                         container.AddComponent("B", typeof(B));
  62                         container.AddComponent("C", typeof(C));
  63
  64                         Assert.IsNotNull(container["A"]);
  65                         Assert.IsNotNull(container["B"]);
  66                         Assert.IsNotNull(container["C"]);
  67                 }
  68
  69                 [Test]
  70                 public void LoadingOutOfSequenceWithExtraLoad()
  71                 {
  72                         container.AddComponent("A", typeof(A));
  73                         container.AddComponent("B", typeof(B));
  74                         container.AddComponent("C", typeof(C));
  75                         container.AddComponent("NotUsed", typeof(int));
  76
  77                         Assert.IsNotNull(container["A"]);
  78                         Assert.IsNotNull(container["B"]);
  79                         Assert.IsNotNull(container["C"]);
  80                 }
  81
  82                 [Test]
  83                 public void CtorSourceOrderDoesNotMatter()
  84                 {
  85                         container.AddComponent("D", typeof(D));
  86                         Assert.IsNotNull(container["D"]);
  87                 }
  88
  89                 public class A
  90                 {
  91                         public A(B b)
  92                         {
  93                         }
  94                 }
  95
  96                 public class B
  97                 {
  98                         public B(C b)
  99                         {
 100                         }
 101                 }
 102
 103                 public class C
 104                 {
 105                         public C()
 106                         {
 107                         }
 108                 }
 109
 110                 public class D
 111                 {
 112                         public D(B b)
 113                         {
 114                         }
 115
 116                         public D()
 117                         {
 118                         }
 119                 }
 120         }
 121 }