org.scalatest.Doc.scala Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2001-2013 Artima, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.scalatest

import java.util.concurrent.atomic.AtomicReference
import scala.xml.Elem
import Doc.stripMargin
import Doc.trimMarkup
import Suite.reportMarkupProvided
import collection.mutable.ListBuffer
import java.util.ConcurrentModificationException

/**
 * A Doc class that takes one XML node markup
 *  which will be returned from its nestedSuites method.
 *
 * 
 * For example, you can define a suite that always executes a list of
 * nested suites like this:
 * 
 *
 *  * class StepsSuite extends Suites(
 *   new Step1Suite,
 *   new Step2Suite,
 *   new Step3Suite,
 *   new Step4Suite,
 *   new Step5Suite
 * )
 * 
 *
 * 
 * When StepsSuite is executed, it will execute its
 * nested suites in the passed order: Step1Suite, Step2Suite,
 * Step3Suite, Step4Suite, and Step5Suite.
 * 
 *
 * @param suitesToNest a sequence of Suites to nest.
 *
 * @throws NullArgumentException if suitesToNest, or any suite
 * it contains, is null.
 *
 * @author Bill Venners
 */
private[scalatest] trait Doc extends Suite { thisDoc =>

  // If registrationThreadName is None, then registration isn't open
  // and include calls will return what they are supposed to return, but
  // won't have the side effect of registering the suites and tests to run.
  private class Bundle private(
    val registrationThreadName: Option[String],
    val registeredSuites: Map[String, Suite]
  ) {
    def unpack = (registrationThreadName, registeredSuites)
  }

  private object Bundle {
    def apply(
      registrationThreadName: Option[String],
      registeredSuites: Map[String, Suite]
    ): Bundle =
      new Bundle(registrationThreadName, registeredSuites)
  }

  private final val atomic = new AtomicReference[Bundle](Bundle(None, Map()))

  private def updateAtomic(oldBundle: Bundle, newBundle: Bundle): Unit = {
    val shouldBeOldBundle = atomic.getAndSet(newBundle)
    if (!(shouldBeOldBundle eq oldBundle))
      throw new ConcurrentModificationException("concurrentDocSpecMod")
  }

  // TODO: Make it atomic
  // TODO: A test that throws NotAllowedE if it is called twice
  // TODO: A test that throws TestRegistrationClosedE if it is called after run has been called
  private var bodyText: Option[String] = None
  def body(elem: Elem): Unit = {
    bodyText = Some(elem.text)
  }

  protected def include(suite: Suite): String = {

      val oldBundle = atomic.get
      var (registrationThreadName, registeredSuites) = oldBundle.unpack
// TODO: register two instances of the same class, which will break this key
      registeredSuites += (suite.getClass.getName -> suite) // TODO: Check thread name, do nothing if None or non-matching
      updateAtomic(oldBundle, Bundle(registrationThreadName, registeredSuites))
    "\ninclude[" + suite.getClass.getName + "]\n"
  }

  // TODO write a test to ensure you get a proper exception when
  // body is not called
  private lazy val snippets: Vector[Snippet] = getSnippets(bodyText.get)

  /*
   * Returns a list containing the suites mentioned in the body XML element,
   * in the order they were mentioned.
   */
  final override lazy val nestedSuites: collection.immutable.IndexedSeq[Suite] = for (IncludedSuite(suite) <- snippets) yield suite
/*
println("^^^^^^^^^^^")
println(body.text)
println("###########")
println(snippets)
println("&&&&&&&&&&&")
*/

/*
  override protected def runNestedSuites(reporter: Reporter, stopper: Stopper, filter: Filter,
      configMap: ConfigMap, distributor: Option[Distributor], tracker: Tracker) {
    reportMarkupProvided(thisDoc, reporter, tracker, None, trimMarkup(stripMargin(body.text)), 0, true, None, None)
  }
*/
  override protected def runNestedSuites(args: Args): Status = {

    import args._

    val statusBuffer = new ListBuffer[Status]()

    val (_, registeredSuites) = atomic.get.unpack
    snippets foreach {
      case Markup(text) =>
        reportMarkupProvided(thisDoc, reporter, tracker, None, trimMarkup(Doc.stripMargin(text)), 0, None, true)
      case IncludedSuite(suite) =>
        println("Send SuiteStarting ... ")  // TODO: Why is runTestedSuites even here?
        statusBuffer += suite.run(None, args)
        println("Send SuiteCompleted or Aborted ...")
    }
    new CompositeStatus(Set.empty ++ statusBuffer)
  }

  private[scalatest] def getSnippets(text: String): Vector[Snippet] = {
//println("text: " + text)
    val lines = Vector.empty ++ text.linesIterator.toIterable
//println("lines: " + lines)
    val pairs = lines map { line =>
      val trimmed = line.trim
      val suite =
        if (trimmed.startsWith("include[") && trimmed.endsWith("]")) {
//println("GOT HERE: " + trimmed + ", " + trimmed.substring(8).init)
          Some(trimmed.substring(8).init)
}
        else
          None
      (line, suite)
    }
//println("pairs: " + pairs)
    // val zipped = pairs.zipWithIndex
    // val insertionIndexes = for (((_, Some(_)), index) <- zipped) yield index
// Output of my fold left is: List[Snippet] (left is a list of snippets, right is a pair
    val backwards =
      (Vector[Snippet](Markup("")) /: pairs) { (left: Vector[Snippet], right: (String, Option[String])) =>
        right match {
          case (_, Some(key)) =>
            var (_, registeredSuites) = atomic.get.unpack
// TODO: Maybe give a better error message if this key doesn't exist?
            IncludedSuite(registeredSuites(key)) +: left
          case (line, None) =>
            left.head match {
              case Markup(text) => Markup(text + "\n" + line) +: left.tail
              case _ => Markup(line) +: left
            }
        }
      }
    backwards.reverse
  }

  private[scalatest] sealed trait Snippet extends Product with Serializable
  private[scalatest] case class Markup(text: String) extends Snippet
  private[scalatest] case class IncludedSuite(suite: Suite) extends Snippet
}

private[scalatest] object Doc {

  private[scalatest] def trimMarkup(text: String): String = {
    val lines = text.linesIterator.toList
    val zipLines = lines.zipWithIndex
    val firstNonWhiteLine = zipLines.find { case (line, _) => !line.trim.isEmpty }
    val lastNonWhiteLine = zipLines.reverse.find { case (line, _) => !line.trim.isEmpty }
    (firstNonWhiteLine, lastNonWhiteLine) match {
      case (None, None) => text.trim // Will be either (None, None) or (Some, Some)
      case (Some((_, frontIdx)), Some((_, backIdx))) => lines.take(backIdx + 1).drop(frontIdx).mkString("\n")
    }
  }

  private[scalatest] def stripMargin(text: String): String = {
    val lines = text.linesIterator.toList
    val firstNonWhiteLine = lines.find(!_.trim.isEmpty)
    firstNonWhiteLine match {
      case None => text.trim
      case Some(nonWhiteLine) =>
        val initialWhite = nonWhiteLine.dropWhile(_.isWhitespace)
        val margin =  nonWhiteLine.length - initialWhite.length
        val choppedLines = lines map { line =>
          val strip = if (line.length > margin) margin else line.length
          line.substring(strip)
        }
        choppedLines.mkString("\n")
    }
  }
}