implemented gouped execution.

src/main/scala/org/scalatest/managedfixture/FeatureSpec.scala

@@ -95,6 +95,7 @@ private[scalatest] class InternalFeatureSpec[T <: FixtureStateTypes](owner: Feat
  */
 trait FeatureSpec[T <: FixtureStateTypes] extends fixture.Suite
                                           with ExternalSuite[T]
+                                          with Grouped
 {
 
 
@@ -109,13 +110,12 @@ trait FeatureSpec[T <: FixtureStateTypes] extends fixture.Suite
   def fixtureStateTypes: T
 
 
-  protected override lazy val internalSpec: InternalFeatureSpec[T] = new InternalFeatureSpec[T](this);
+  protected override lazy val internalSpec: InternalFeatureSpec[T] = createInternalSpec(
+                                                                        (x:FeatureSpecGroup[T]) => x.internalSpec,
+                                                                        new InternalFeatureSpec(this)
+                                                                      )
 
 
-  override def withFixture(test: OneArgTest): Unit =
-          throw new IllegalStateException("You can't call withFixture diretly in managedfixture");
-
-
   override protected def fixtureUsageDSLValueAction(value: => TestFixtureStateUsageDescription[T]): Unit =
   {
    internalSpec.fixtureUsage(value);
@@ -136,7 +136,8 @@ trait FeatureSpec[T <: FixtureStateTypes] extends fixture.Suite
 
   override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
       configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
-     internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker)
+     runGrouped(testName, reporter, stopper, filter, configMap, distributor, tracker,internalSpec,
+                 classOf[FeatureSpec[T]])
   }
 
   protected def scenariosFor(unit: Unit) {}

src/main/scala/org/scalatest/managedfixture/FeatureSpecGroup.scala

@@ -0,0 +1,20 @@
+package org.scalatest.managedfixture
+
+import ua.gradsoft.managedfixture._
+import org.scalatest._
+
+abstract class FeatureSpecGroup[T <: FixtureStateTypes] extends managedfixture.FeatureSpec[T]
+                                                           with SpecGroup
+{
+
+  execution autonomic
+
+  override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
+    collectGrouped(classOf[FeatureSpec[T]]);
+    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker);
+  }
+
+
+
+}

src/main/scala/org/scalatest/managedfixture/FlatSpec.scala

@@ -180,6 +180,7 @@ private[scalatest] class InternalFlatSpec[T <: FixtureStateTypes](val owner:Flat
   */
 trait FlatSpec[T <: FixtureStateTypes] extends Suite with ShouldVerb with MustVerb with CanVerb 
                                            with FixtureStateDSL[T]
+                                           with Grouped
 { 
 
   type FixtureStateTypes = T;
@@ -203,17 +204,8 @@ trait FlatSpec[T <: FixtureStateTypes] extends Suite with ShouldVerb with MustVe
 
   // here we recreate internal suite and will be pass to one all 'real' functionality.
   private[scalatest] lazy val internalSpec: InternalFlatSpec[T] = 
-                                            if (this.isInstanceOf[Grouped]) {
-                                               if (GroupSpecConstructorKluge.currentOwner!=None) {
-                                                 GroupSpecConstructorKluge.currentOwner.value.get.asInstanceOf[FlatSpecGroup[T]].internalSpec;
-                                               } else {
-                                                  // it was called outside group, create internal constructor
-                                                  new InternalFlatSpec(this);
-                                               }
-                                             } else {
-                                               new InternalFlatSpec(this); 
-                                             }
-
+                        createInternalSpec( (x:FlatSpecGroup[T])=>x.internalSpec, new InternalFlatSpec(this)  );
+
   implicit protected def info: Informer = internalSpec._info;
 
   protected final class BehaviorWord {
@@ -389,16 +381,15 @@ trait FlatSpec[T <: FixtureStateTypes] extends Suite with ShouldVerb with MustVe
   }
 
   override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
-      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
-    if (isGrouped) {
-       this.asInstanceOf[Grouped].checkGroupExists( classOf[FlatSpecGroup[_]] );
-    }
-    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker);
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit = 
+  {      
+    runGrouped(testName, reporter, stopper, filter, configMap, distributor, tracker, 
+               internalSpec,classOf[FlatSpecGroup[T]]); 
   }
+
 
   protected val behave = new BehaveWord
 
-  private def isGrouped: Boolean = this.isInstanceOf[Grouped];
 }
 
 private[scalatest] object FlatSpecConstructorKluge

src/main/scala/org/scalatest/managedfixture/FlatSpecGroup.scala

@@ -6,9 +6,11 @@ import org.scalatest._
 import ua.gradsoft.managedfixture._
 
 
-abstract class FlatSpecGroup[T <: FixtureStateTypes] extends FlatSpec[T] 
+abstract class FlatSpecGroup[T <: FixtureStateTypes] extends managedfixture.FlatSpec[T] 
                                                      with SpecGroup
 {
+
+  execution autonomic
 
   override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
       configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {

src/main/scala/org/scalatest/managedfixture/FreeSpec.scala

@@ -100,8 +100,9 @@ private[scalatest] class InternalFreeSpec[T <: ua.gradsoft.managedfixture.Fixtur
  *}}}
  *@see [[ua.gradsoft.managedfixture]], [[org.scalatest.fixture]]
  */
-trait FreeSpec[T <: ua.gradsoft.managedfixture.FixtureStateTypes] extends fixture.Suite 
+trait FreeSpec[T <: FixtureStateTypes] extends fixture.Suite 
                                         with ExternalSuite[T]
+                                        with Grouped
 { 
 
 
@@ -115,11 +116,12 @@ trait FreeSpec[T <: ua.gradsoft.managedfixture.FixtureStateTypes] extends fixtur
    **/
   def fixtureStateTypes: T
 
-  override final def withFixture(test: OneArgTest): Unit =
-          throw new IllegalStateException("You can't call withFixture diretly in managedfixture");
-
-  protected lazy val internalSpec = new InternalFreeSpec[T](this);
 
+  protected lazy val internalSpec: InternalFreeSpec[T] = createInternalSpec(
+                                                           (x:FreeSpecGroup[T]) => x.internalSpec,
+                                                           new InternalFreeSpec[T](this)
+                                                         );
+
   protected final class ResultOfTaggedAsInvocationOnString(specText: String, tags: List[Tag]) {
     def in(testFun: FixtureParam => Any) {
       internalSpec.taggedInvocationOnString_in(specText, tags, testFun);
@@ -186,8 +188,9 @@ trait FreeSpec[T <: ua.gradsoft.managedfixture.FixtureStateTypes] extends fixtur
   protected implicit def convertToFreeSpecStringWrapper(s: String) = new FreeSpecStringWrapper(s)
 
   override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
-      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
-    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker)
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit = {
+       runGrouped(testName, reporter, stopper, filter, configMap, distributor, tracker,
+           internalSpec, classOf[managedfixture.FreeSpecGroup[T]])
   }
 
   protected val behave = new BehaveWord

src/main/scala/org/scalatest/managedfixture/FreeSpecGroup.scala

@@ -0,0 +1,21 @@
+package org.scalatest.managedfixture
+
+import org.scalatest._
+import ua.gradsoft.managedfixture._
+
+
+abstract class FreeSpecGroup[T <: FixtureStateTypes] extends managedfixture.FreeSpec[T] 
+                                              with SpecGroup
+{
+
+  execution autonomic
+
+  override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
+    collectGrouped(classOf[managedfixture.FreeSpec[T]]);
+    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker);
+  }
+
+
+
+}

src/main/scala/org/scalatest/managedfixture/FunSpec.scala

@@ -10,8 +10,8 @@ import ua.gradsoft.managedfixture._
 /**
  * internal trait where all expression are reevaluated
  **/
-private[scalatest] class InternalFunSpec[T <: ua.gradsoft.managedfixture.FixtureStateTypes](owner: FunSpec[T]) 
-                                extends InternalSuite[T,FunSpec[T]](owner)
+private[scalatest] class InternalFunSpec[T <: FixtureStateTypes](owner: FunSpec[T]) 
+                                extends InternalSuite[T,managedfixture.FunSpec[T]](owner)
                                     with fixture.FunSpec
 {
 
@@ -84,13 +84,12 @@ private[scalatest] class InternalFunSpec[T <: ua.gradsoft.managedfixture.Fixture
  */
 trait FunSpec[T <: ua.gradsoft.managedfixture.FixtureStateTypes] extends fixture.Suite
                                           with ExternalSuite[T]
+                                          with Grouped
 { 
 
-  protected override val internalSpec = new InternalFunSpec[T](this);
-
-  override def withFixture(test: OneArgTest): Unit =
-          throw new IllegalStateException("You can't call withFixture diretly in managedfixture");
-
+  protected override val internalSpec: InternalFunSpec[T] = createInternalSpec((x:FunSpecGroup[T])=>x.internalSpec, new InternalFunSpec(this));
+
+
   protected final class ItWord {
 
     def apply(specText: String, testTags: Tag*)(testFun: FixtureParam => Any) {
@@ -117,8 +116,8 @@ trait FunSpec[T <: ua.gradsoft.managedfixture.FixtureStateTypes] extends fixture
   }
 
   override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
-      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
-    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker)
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit = {
+      runGrouped(testName, reporter, stopper, filter, configMap, distributor, tracker, internalSpec, classOf[FunSpecGroup[T]] )
   }
 
   protected val behave = new BehaveWord

src/main/scala/org/scalatest/managedfixture/FunSpecGroup.scala

@@ -0,0 +1,19 @@
+package org.scalatest.managedfixture
+
+import ua.gradsoft.managedfixture._
+import org.scalatest._
+
+abstract class FunSpecGroup[T <: FixtureStateTypes] extends managedfixture.FunSpec[T]
+                                                     with SpecGroup
+{
+
+  execution autonomic
+
+  override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
+    collectGrouped(classOf[managedfixture.FunSpec[T]]);
+    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker);
+  }
+
+
+}

src/main/scala/org/scalatest/managedfixture/FunSuite.scala

@@ -3,6 +3,40 @@ package org.scalatest.managedfixture
 import org.scalatest._
 import ua.gradsoft.managedfixture._
 
+
+private[scalatest] class InternalFunSuite[T <: FixtureStateTypes](owner: managedfixture.FunSuite[T]) 
+                                extends InternalSuite[T,managedfixture.FunSuite[T]](owner)
+                                    with fixture.FunSuite
+{
+
+  def this() =
+     this(InternalSuiteConstructorKluge.currentOwner.value.get.asInstanceOf[FunSuite[T]])
+
+  def putTestWhenNested(specTest: String, tags: List[Tag], testFun: FixtureParam=>Any):Unit =
+  {
+    test(specTest, tags: _* )(testFun);   
+  }
+
+  def _test(testName: String, testTags: Tag*)(testFun: FixtureParam => Any): Unit = {
+    if (!isNested) {
+      setFixtureStateForTest(testName,testTags.toList,testFun)
+    } else {
+      test(testName,testTags:_*)(testFun);
+    }
+  }
+
+
+  def _ignore(testName: String, testTags: Tag*)(testFun: FixtureParam => Any): Unit = {
+    ignore(testName, testTags:_*)(testFun)
+  }
+
+  def _info = info
+
+  private[scalatest] override def fullTestName(text:String) = text;
+
+
+}
+
 /**
  * Sister trait for <code> org.scalates.fixture.FunSuite </code> 
  * 
@@ -38,34 +72,32 @@ import ua.gradsoft.managedfixture._
  * }}}
  *
  **/
-trait FunSuite[T <: ua.gradsoft.managedfixture.FixtureStateTypes] extends org.scalatest.fixture.FunSuite
-                                           with AbstractManagedFixtureStateSuite[T]
+trait FunSuite[T <: FixtureStateTypes] extends fixture.FunSuite
+                                           with ExternalSuite[T]
+                                           with Grouped
 {
-  thisSuite =>
+   
 
-  protected override def test(testName: String, testTags: Tag*)(testFun: FixtureParam => Any) {
-    if (!isNested) {
-                                      // think: may be better complain ?
-      neededFixtureStates(testName) = fixtureStateForNextTest.getOrElse(defaultFixtureState);
-      val nestedTestSuite = createNestedInstanceForTest(testName);
-      // not needed - will be called during construction.
-      //nestedTestSuite.test(testName, testTags: _* )(testFun);
-      suitesToRun(testName) = nestedTestSuite;
-    } else {
-      if (testName == _parentTestName.get) {
-        super.test(testName, testTags: _* )(testFun);
-      }
-    }
+  lazy val internalSpec: InternalFunSuite[T] = createInternalSpec(((x:FunSuiteGroup[T]) => x.internalSpec),
+                                                                   new InternalFunSuite[T](this));
+
+  protected override def test(testName: String, testTags: Tag*)(testFun: FixtureParam => Any): Unit = {
+    internalSpec._test(testName, testTags:_*)(testFun)
   }
-
-  protected override def ignore(testName: String, testTags: Tag*)(testFun: FixtureParam => Any) {
-    if (!isNested) {
-      // all ignred comt to top-level.
-      super.ignore(testName, testTags:_*)(testFun);
-    } 
+
+  protected override def ignore(testName: String, testTags: Tag*)(testFun: FixtureParam => Any):Unit = {
+    internalSpec._ignore(testName, testTags:_*)(testFun);
   }
-
 
+  implicit protected override def info: Informer = internalSpec._info
+
+  override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
+                   configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit =
+        runGrouped(testName,reporter,stopper,filter,configMap, distributor, tracker,
+                   internalSpec, classOf[FunSpecGroup[T]])
+
+
+
 }
 
 // vim: set ts=4 sw=4 et:

src/main/scala/org/scalatest/managedfixture/FunSuiteGroup.scala

@@ -0,0 +1,20 @@
+package org.scalatest.managedfixture
+
+import ua.gradsoft.managedfixture._
+import org.scalatest._
+
+abstract class FunSuiteGroup[T <: FixtureStateTypes] extends managedfixture.FunSuite[T]
+                                                             with SpecGroup
+{
+
+
+  execution autonomic
+
+  override def run(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter,
+      configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker) {
+    collectGrouped(classOf[managedfixture.FunSpec[T]]);
+    internalSpec.run(testName, reporter, stopper, filter, configMap, distributor, tracker);
+  }
+
+
+}