nunit24/NUnitCore/core/NamespaceTreeBuilder.cs

   1 // ****************************************************************
   2 // This is free software licensed under the NUnit license. You
   3 // may obtain a copy of the license as well as information regarding
   4 // copyright ownership at http://nunit.org/?p=license&r=2.4.
   5 // ****************************************************************
   6
   7 using System.Collections;
   8
   9 namespace NUnit.Core
  10 {
  11         /// <summary>
  12         /// Class that can build a tree of automatic namespace
  13         /// suites from a group of fixtures.
  14         /// </summary>
  15         public class NamespaceTreeBuilder
  16         {
  17                 #region Instance Variables
  18
  19                 /// <summary>
  20                 /// Hashtable of all test suites we have created to represent namespaces.
  21                 /// Used to locate namespace parent suites for fixtures.
  22                 /// </summary>
  23                 Hashtable namespaceSuites  = new Hashtable();
  24
  25                 /// <summary>
  26                 /// The root of the test suite being created by this builder.
  27                 /// </summary>
  28                 TestSuite rootSuite;
  29
  30                 #endregion
  31
  32                 #region Constructor
  33
  34                 public NamespaceTreeBuilder( TestSuite rootSuite )
  35                 {
  36                         this.rootSuite = rootSuite;
  37                 }
  38
  39                 #endregion
  40
  41                 #region Properties
  42
  43                 public TestSuite RootSuite
  44                 {
  45                         get { return rootSuite; }
  46                 }
  47
  48                 #endregion
  49
  50                 #region Public Methods
  51
  52                 public void Add( IList fixtures )
  53                 {
  54             foreach (TestSuite fixture in fixtures)
  55                 //if (fixture is SetUpFixture)
  56                 //    Add(fixture as SetUpFixture);
  57                 //else
  58                     Add( fixture );
  59                 }
  60
  61                 public void Add( TestSuite fixture )
  62                 {
  63
  64                         string ns = fixture.TestName.FullName;
  65             int index = ns.LastIndexOf( '.' );
  66             ns = index > 0 ? ns.Substring( 0, index ) : string.Empty;
  67                         TestSuite containingSuite = BuildFromNameSpace( ns );
  68
  69             if (fixture is SetUpFixture)
  70             {
  71                 // The SetUpFixture must replace the namespace suite
  72                 // in which it is "contained".
  73                 //
  74                 // First, add the old suite's children
  75                 foreach (TestSuite child in containingSuite.Tests)
  76                     fixture.Add(child);
  77
  78                 // Make the parent of the containing suite point to this
  79                 // fixture instead
  80                 // TODO: Get rid of this somehow?
  81                 TestSuite parent = (TestSuite)containingSuite.Parent;
  82                 if (parent == null)
  83                 {
  84                     fixture.TestName.Name = rootSuite.TestName.Name;
  85                     rootSuite = fixture;
  86                 }
  87                 else
  88                 {
  89                     parent.Tests.Remove(containingSuite);
  90                     parent.Add(fixture);
  91                 }
  92
  93                 // Update the hashtable
  94                 namespaceSuites[ns] = fixture;
  95             }
  96             else
  97                             containingSuite.Add( fixture );
  98                 }
  99
 100         //public void Add( SetUpFixture fixture )
 101         //{
 102         //    string ns = fixture.FullName;
 103         //    int index = ns.LastIndexOf( '.' );
 104         //    ns = index > 0 ? ns.Substring( 0, index ) : string.Empty;
 105         //    TestSuite suite = BuildFromNameSpace( ns );
 106
 107         //    // Make the parent point to this instead
 108         //    // TODO: Get rid of this somehow?
 109         //    TestSuite parent = suite.Parent;
 110         //    if ( parent != null )
 111         //    {
 112         //        parent.Tests.Remove( suite );
 113         //        parent.Add( fixture );
 114         //    }
 115
 116         //    // Add the old suite's children
 117         //    foreach( TestSuite child in suite.Tests )
 118         //        fixture.Add( child );
 119
 120         //    if (parent == null && fixture is SetUpFixture)
 121         //    {
 122         //        suite.Tests.Clear();
 123         //        suite.Add(fixture);
 124         //    }
 125         //    // Update the hashtable
 126         //    namespaceSuites[ns] = fixture;
 127         //}
 128
 129                 #endregion
 130
 131                 #region Helper Method
 132
 133                 private TestSuite BuildFromNameSpace( string nameSpace )
 134                 {
 135                         if( nameSpace == null || nameSpace  == "" ) return rootSuite;
 136                         TestSuite suite = (TestSuite)namespaceSuites[nameSpace];
 137                         if(suite!=null) return suite;
 138
 139                         int index = nameSpace.LastIndexOf(".");
 140                         //string prefix = string.Format( "[{0}]" );
 141                         if( index == -1 )
 142                         {
 143                                 suite = new TestSuite( nameSpace );
 144                                 if ( rootSuite == null )
 145                                         rootSuite = suite;
 146                                 else
 147                                         rootSuite.Add(suite);
 148                                 namespaceSuites[nameSpace]=suite;
 149                         }
 150                         else
 151                         {
 152                                 string parentNameSpace = nameSpace.Substring( 0,index );
 153                                 TestSuite parent = BuildFromNameSpace( parentNameSpace );
 154                                 string suiteName = nameSpace.Substring( index+1 );
 155                                 suite = new TestSuite( parentNameSpace, suiteName );
 156                                 parent.Add( suite );
 157                                 namespaceSuites[nameSpace] = suite;
 158                         }
 159
 160                         return suite;
 161                 }
 162
 163                 #endregion
 164         }
 165 }