text:
package org.scalatest.fixture

import org.scalatest._
import FixtureNodeFamily._
import words.{ResultOfTaggedAsInvocation, ResultOfStringPassedToVerb, BehaveWord, ShouldVerb, MustVerb, CanVerb}
import scala.collection.immutable.ListSet
import org.scalatest.exceptions.StackDepthExceptionHelper.getStackDepth
import java.util.concurrent.atomic.AtomicReference
import java.util.ConcurrentModificationException
import org.scalatest.events._
import org.scalatest.Suite.anExceptionThatShouldCauseAnAbort
import org.scalatest.Suite.autoTagClassAnnotations

/**
 * Implementation trait for class fixture.FlatSpec, which is
 * a sister class to org.scalatest.FlatSpec that can pass a
 * fixture object into its tests.
 *
 *

 * fixture.FlatSpec is a class,
 * not a trait, to minimize compile time given there is a slight compiler
 * overhead to mixing in traits compared to extending classes. If you need
 * to mix the behavior of fixture.FlatSpec into some other
 * class, you can use this trait instead, because class
 * fixture.FlatSpec does nothing more than extend this trait.
 *

 *
 *

 * See the documentation of the class for a detailed
 * overview of fixture.FlatSpec.
 *

 *
 * @author Bill Venners
 */
@Finders(Array("org.scalatest.finders.FlatSpecFinder"))
trait FlatSpecLike extends Suite with ShouldVerb with MustVerb with CanVerb { thisSuite =>

  private final val engine = new FixtureEngine[FixtureParam]("concurrentFixtureFlatSpecMod", "FixtureFlatSpec")
  import engine._

  private[scalatest] val sourceFileName = "FlatSpecLike.scala"

  /**
   * Returns an Informer that during test execution will forward strings (and other objects) passed to its
   * apply method to the current reporter. If invoked in a constructor, it
   * will register the passed string for forwarding later during test execution. If invoked while this
   * fixture.FlatSpec is being executed, such as from inside a test function, it will forward the information to
   * the current reporter immediately. If invoked at any other time, it will
   * throw an exception. This method can be called safely by any thread.
   */
  implicit protected def info: Informer = atomicInformer.get

  /**
   * Register a test with the given spec text, optional tags, and test function value that takes no arguments.
   * An invocation of this method is called an “example.”
   *
   * This method will register the test for later execution via an invocation of one of the execute
   * methods. The name of the test will be a concatenation of the text of all surrounding describers,
   * from outside in, and the passed spec text, with one space placed between each item. (See the documenation
   * for testNames for an example.) The resulting test name must not have been registered previously on
   * this FlatSpec instance.
   *
   * @param specText the specification text, which will be combined with the descText of any surrounding describers
   * to form the test name
   * @param testTags the optional list of tags for this test
   * @param methodName caller's method name
   * @param testFun the test function
   * @throws DuplicateTestNameException if a test with the same name has been registered previously
   * @throws TestRegistrationClosedException if invoked after run has been invoked on this suite
   * @throws NullPointerException if specText or any passed test tag is null
   */
  private def registerTestToRun(specText: String, testTags: List[Tag], methodName: String, testFun: FixtureParam => Any) {

    // TODO: This is what was being used before but it is wrong
    registerTest(specText, Transformer(testFun), "itCannotAppearInsideAnotherIt", sourceFileName, methodName, 4, -3, None, None, None, testTags: _*)
  }

  /**
   * Class that supports the registration of a “subject” being specified and tested via the
   * instance referenced from fixture.FlatSpec's behavior field.
   *
   *

   * This field enables syntax such as the following subject registration:
   *

   *
   *

   * behavior of "A Stack"
   * ^
   *

   *
   *

   * For more information and examples of the use of the behavior field, see the main documentation
   * for trait fixture.FlatSpec.
   *

   */
  protected final class BehaviorWord {

    /**
     * Supports the registration of a “subject” being specified and tested via the
     * instance referenced from fixture.FlatSpec's behavior field.
     *
     *

     * This method enables syntax such as the following subject registration:
     *

     *
     *

     * behavior of "A Stack"
     *          ^
     *

     *
     *

     * For more information and examples of the use of this method, see the main documentation
     * for trait FlatSpec.
     *

     */
    def of(description: String) {
      registerFlatBranch(description, "describeCannotAppearInsideAnIt", sourceFileName, "of", 3, 0)
    }
  }

  /**
   * Supports the registration of a “subject” being specified and tested.
   *
   *

   * This field enables syntax such as the following subject registration:
   *

   *
   *

   * behavior of "A Stack"
   * ^
   *

   *
   *

   * For more information and examples of the use of the behavior field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected val behavior = new BehaviorWord

  // TODO: Do a walk through. Are all these being used. I guess I'll find out when
  // I document them.
  /**
   * Class that supports the registration of tagged tests via the ItWord instance
   * referenced from fixture.FlatSpec's it field.
   *
   *

   * This class enables syntax such as the following tagged test registration:
   *

   *
   *

   * it should "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
   *                                                                      ^
   *

   *
   *

   * It also enables syntax such as the following registration of an ignored, tagged test:
   *

   *
   *

   * it should "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { ... }
   *                                                                      ^
   *

   *
   *

   * In addition, it enables syntax such as the following registration of a pending, tagged test:
   *

   *
   *

   * it should "pop values in last-in-first-out order" taggedAs(SlowTest) is (pending)
   *                                                                      ^
   *

   *
   *

   * For more information and examples of the use of the it field to register tagged tests, see
   * the Tagging tests section in the main documentation for trait FlatSpec.
   *

   */
  protected final class ItVerbStringTaggedAs(verb: String, name: String, tags: List[Tag]) {

    /**
     * Supports the registration of tagged, no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" taggedAs(SlowTest) in { () => ... }
     *                                                                    ^
     *

     *
     *

     * For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToRun(verb.trim + " " + name.trim, tags, "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of tagged, one-arg tests (tests that take a FixtureParam object as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" taggedAs(SlowTest) in { fixture => ... }
     *                                                                    ^
     *

     *
     *

     * For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToRun(verb.trim + " " + name.trim, tags, "in", testFun)
    }

    /**
     * Supports the registration of pending, tagged tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" taggedAs(SlowTest) is (pending)
     *                                                                    ^
     *

     *
     *

     * For examples of pending test registration, see the Pending tests section in the main documentation
     * for trait FlatSpec.  And for examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def is(testFun: => PendingNothing) {
      registerTestToRun(verb.trim + " " + name.trim, tags, "is", unusedFixtureParam => testFun)
    }

    /**
     * Supports the registration of ignored, tagged, no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { () => ... }
     *                                                                    ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.  And for examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "ignore", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored, tagged, one-arg tests (tests that take a FixtureParam object
     * as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { fixture => ... }
     *                                                                    ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.  And for examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "ignore", testFun)
    }
  }

  /**
   * Class that supports test registration via the instance referenced from fixture.FlatSpec's it field.
   *
   *

   * This class enables syntax such as the following test registration:
   *

   *
   *

   * it should "pop values in last-in-first-out order" in { ... }
   *                                                   ^
   *

   *
   *

   * It also enables syntax such as the following registration of an ignored test:
   *

   *
   *

   * it should "pop values in last-in-first-out order" ignore { ... }
   *                                                   ^
   *

   *
   *

   * In addition, it enables syntax such as the following registration of a pending test:
   *

   *
   *

   * it should "pop values in last-in-first-out order" is (pending)
   *                                                   ^
   *

   *
   *

   * And finally, it also enables syntax such as the following tagged test registration:
   *

   *
   *

   * it should "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
   *                                                   ^
   *

   *
   *

   * For more information and examples of the use of the it field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected final class ItVerbString(verb: String, name: String) {

    /**
     * Supports the registration of no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" in { () => ... }
     *                                                 ^
     *

     *
     *

     * For examples of no-arg test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToRun(verb.trim + " " + name.trim, List(), "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of one-arg tests (tests that take a FixtureParam object as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" in { fixture => ... }
     *                                                 ^
     *

     *
     *

     * For examples of one-arg test registration, see the main documentation
     * for trait fixture.FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToRun(verb.trim + " " + name.trim, List(), "in", testFun)
    }

    /**
     * Supports the registration of pending tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" is (pending)
     *                                                 ^
     *

     *
     *

     * For examples of pending test registration, see the Pending tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def is(testFun: => PendingNothing) {
      registerTestToRun(verb.trim + " " + name.trim, List(), "is", unusedFixtureParam => testFun)
    }

    /**
     * Supports the registration of ignored no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" ignore { () => ... }
     *                                                 ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def ignore(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "ignore", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored one-arg tests (tests that take a FixtureParam object as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" ignore { fixture => ... }
     *                                                 ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def ignore(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "ignore", testFun)
    }

    /**
     * Supports the registration of tagged tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
     *                                                 ^
     *

     *
     *

     * For examples of tagged test registration, see the Tagging tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
      val tagList = firstTestTag :: otherTestTags.toList
      new ItVerbStringTaggedAs(verb, name, tagList)
    }
  }

  /**
   * Class that supports test (and shared test) registration via the instance referenced from fixture.FlatSpec's it field.
   *
   *

   * This class enables syntax such as the following test registration:
   *

   *
   *

   * it should "pop values in last-in-first-out order" in { ... }
   * ^
   *

   *
   *

   * It also enables syntax such as the following shared test registration:
   *

   *
   *

   * it should behave like nonEmptyStack(lastItemPushed)
   * ^
   *

   *
   *

   * For more information and examples of the use of the it field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected final class ItWord {

    /**
     * Supports the registration of tests with should in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it should "pop values in last-in-first-out order" in { ... }
     *    ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def should(string: String) = new ItVerbString("should", string)

    /**
     * Supports the registration of tests with must in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must "pop values in last-in-first-out order" in { ... }
     *    ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def must(string: String) = new ItVerbString("must", string)

    /**
     * Supports the registration of tests with can in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it can "pop values in last-in-first-out order" in { ... }
     *    ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def can(string: String) = new ItVerbString("can", string)

    /**
     * Supports the registration of shared tests with should in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it should behave like nonFullStack(stackWithOneItem)
     *    ^
     *

     *
     *

     * For examples of shared tests, see the Shared tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def should(behaveWord: BehaveWord) = behaveWord

    /**
     * Supports the registration of shared tests with must in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it must behave like nonFullStack(stackWithOneItem)
     *    ^
     *

     *
     *

     * For examples of shared tests, see the Shared tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def must(behaveWord: BehaveWord) = behaveWord

    /**
     * Supports the registration of shared tests with can in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * it can behave like nonFullStack(stackWithOneItem)
     *    ^
     *

     *
     *

     * For examples of shared tests, see the Shared tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def can(behaveWord: BehaveWord) = behaveWord
  }

  /**
   * Supports test (and shared test) registration in fixture.FlatSpecs.
   *
   *

   * This field enables syntax such as the following test registration:
   *

   *
   *

   * it should "pop values in last-in-first-out order" in { ... }
   * ^
   *

   *
   *

   * It also enables syntax such as the following shared test registration:
   *

   *
   *

   * it should behave like nonEmptyStack(lastItemPushed)
   * ^
   *

   *
   *

   * For more information and examples of the use of the it field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected val it = new ItWord

  /**
   * Class that supports the registration of tagged tests via the TheyWord instance
   * referenced from fixture.FlatSpec's they field.
   *
   *

   * This class enables syntax such as the following tagged test registration:
   *

   *
   *

   * they should "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
   *                                                                        ^
   *

   *
   *

   * It also enables syntax such as the following registration of an ignored, tagged test:
   *

   *
   *

   * they should "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { ... }
   *                                                                        ^
   *

   *
   *

   * In addition, it enables syntax such as the following registration of a pending, tagged test:
   *

   *
   *

   * they should "pop values in last-in-first-out order" taggedAs(SlowTest) is (pending)
   *                                                                        ^
   *

   *
   *

   * For more information and examples of the use of the it field to register tagged tests, see
   * the Tagging tests section in the main documentation for trait FlatSpec.
   *

   */
  protected final class TheyVerbStringTaggedAs(verb: String, name: String, tags: List[Tag]) {

    /**
     * Supports the registration of tagged, no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" taggedAs(SlowTest) in { () => ... }
     *                                                                      ^
     *

     *
     *

     * For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToRun(verb.trim + " " + name.trim, tags, "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of tagged, one-arg tests (tests that take a FixtureParam object as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" taggedAs(SlowTest) in { fixture => ... }
     *                                                                      ^
     *

     *
     *

     * For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToRun(verb.trim + " " + name.trim, tags, "in", testFun)
    }

    /**
     * Supports the registration of pending, tagged tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" taggedAs(SlowTest) is (pending)
     *                                                                      ^
     *

     *
     *

     * For examples of pending test registration, see the Pending tests section in the main documentation
     * for trait FlatSpec.  And for examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def is(testFun: => PendingNothing) {
      registerTestToRun(verb.trim + " " + name.trim, tags, "is", unusedFixtureParam => testFun)
    }

    /**
     * Supports the registration of ignored, tagged, no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { () => ... }
     *                                                                      ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.  And for examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "ignore", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored, tagged, one-arg tests (tests that take a FixtureParam object
     * as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { fixture => ... }
     *                                                                      ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.  And for examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "ignore", testFun)
    }
  }

  /**
   * Class that supports test registration via the instance referenced from fixture.FlatSpec's it field.
   *
   *

   * This class enables syntax such as the following test registration:
   *

   *
   *

   * they should "pop values in last-in-first-out order" in { ... }
   *                                                     ^
   *

   *
   *

   * It also enables syntax such as the following registration of an ignored test:
   *

   *
   *

   * they should "pop values in last-in-first-out order" ignore { ... }
   *                                                     ^
   *

   *
   *

   * In addition, it enables syntax such as the following registration of a pending test:
   *

   *
   *

   * they should "pop values in last-in-first-out order" is (pending)
   *                                                     ^
   *

   *
   *

   * And finally, it also enables syntax such as the following tagged test registration:
   *

   *
   *

   * they should "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
   *                                                     ^
   *

   *
   *

   * For more information and examples of the use of the it field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected final class TheyVerbString(verb: String, name: String) {

    /**
     * Supports the registration of no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" in { () => ... }
     *                                                   ^
     *

     *
     *

     * For examples of no-arg test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToRun(verb.trim + " " + name.trim, List(), "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of one-arg tests (tests that take a FixtureParam object as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" in { fixture => ... }
     *                                                   ^
     *

     *
     *

     * For examples of one-arg test registration, see the main documentation
     * for trait fixture.FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToRun(verb.trim + " " + name.trim, List(), "in", testFun)
    }

    /**
     * Supports the registration of pending tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" is (pending)
     *                                                   ^
     *

     *
     *

     * For examples of pending test registration, see the Pending tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def is(testFun: => PendingNothing) {
      registerTestToRun(verb.trim + " " + name.trim, List(), "is", unusedFixtureParam => testFun)
    }

    /**
     * Supports the registration of ignored no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" ignore { () => ... }
     *                                                   ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def ignore(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "ignore", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored one-arg tests (tests that take a FixtureParam object as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" ignore { fixture => ... }
     *                                                   ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def ignore(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "ignore", testFun)
    }

    /**
     * Supports the registration of tagged tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
     *                                                   ^
     *

     *
     *

     * For examples of tagged test registration, see the Tagging tests section in the main documentation
     * for trait FlatSpec.
     *

     */
    def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
      val tagList = firstTestTag :: otherTestTags.toList
      new ItVerbStringTaggedAs(verb, name, tagList)
    }
  }

  /**
   * Class that supports test (and shared test) registration via the instance referenced from fixture.FlatSpec's it field.
   *
   *

   * This class enables syntax such as the following test registration:
   *

   *
   *

   * they should "pop values in last-in-first-out order" in { ... }
   * ^
   *

   *
   *

   * It also enables syntax such as the following shared test registration:
   *

   *
   *

   * they should behave like nonEmptyStack(lastItemPushed)
   * ^
   *

   *
   *

   * For more information and examples of the use of the it field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected final class TheyWord {

    /**
     * Supports the registration of tests with should in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they should "pop values in last-in-first-out order" in { ... }
     *      ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def should(string: String) = new ItVerbString("should", string)

    /**
     * Supports the registration of tests with must in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must "pop values in last-in-first-out order" in { ... }
     *      ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def must(string: String) = new ItVerbString("must", string)

    /**
     * Supports the registration of tests with can in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they can "pop values in last-in-first-out order" in { ... }
     *      ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait FlatSpec.
     *

     */
    def can(string: String) = new ItVerbString("can", string)

    /**
     * Supports the registration of shared tests with should in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they should behave like nonFullStack(stackWithOneItem)
     *      ^
     *

     *
     *

     * For examples of shared tests, see the Shared tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def should(behaveWord: BehaveWord) = behaveWord

    /**
     * Supports the registration of shared tests with must in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they must behave like nonFullStack(stackWithOneItem)
     *      ^
     *

     *
     *

     * For examples of shared tests, see the Shared tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def must(behaveWord: BehaveWord) = behaveWord

    /**
     * Supports the registration of shared tests with can in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * they can behave like nonFullStack(stackWithOneItem)
     *      ^
     *

     *
     *

     * For examples of shared tests, see the Shared tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def can(behaveWord: BehaveWord) = behaveWord
  }

  /**
   * Supports test (and shared test) registration in fixture.FlatSpecs.
   *
   *

   * This field enables syntax such as the following test registration:
   *

   *
   *

   * they should "pop values in last-in-first-out order" in { ... }
   * ^
   *

   *
   *

   * It also enables syntax such as the following shared test registration:
   *

   *
   *

   * they should behave like nonEmptyStack(lastItemPushed)
   * ^
   *

   *
   *

   * For more information and examples of the use of the it field, see the main documentation
   * for trait FlatSpec.
   *

   */
  protected val they = new TheyWord

  /**
   * Class that supports registration of ignored, tagged tests via the IgnoreWord instance referenced
   * from fixture.FlatSpec's ignore field.
   *
   *

   * This class enables syntax such as the following registration of an ignored, tagged test:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
   *                                                                          ^
   *

   *
   *

   * In addition, it enables syntax such as the following registration of an ignored, tagged, pending test:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" taggedAs(SlowTest) is (pending)
   *                                                                          ^
   *

   *
   *

   * Note: the is method is provided for completeness and design symmetry, given there's no way
   * to prevent changing is to ignore and marking a pending test as ignored that way.
   * Although it isn't clear why someone would want to mark a pending test as ignored, it can be done.
   *

   *
   *

   * For more information and examples of the use of the ignore field, see
   * the Ignored tests section
   * in the main documentation for trait FlatSpec. For examples of tagged test registration, see
   * the Tagging tests section in the main documentation for trait FlatSpec.
   *

   */
  protected final class IgnoreVerbStringTaggedAs(verb: String, name: String, tags: List[Tag]) {

    /**
     * Supports the registration of ignored, tagged, no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" taggedAs(SlowTest) in { () => ... }
     *                                                                        ^
     *

     *
     *

     * For examples of the registration of ignored tests, see the Ignored tests section
     * in the main documentation for trait FlatSpec. For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored, tagged, one-arg tests (tests that take a FixtureParam object as a parameter)
     * in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" taggedAs(SlowTest) in { fixture => ... }
     *                                                                        ^
     *

     *
     *

     * For examples of the registration of ignored tests, see the Ignored tests section
     * in the main documentation for trait FlatSpec. For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "in", testFun)
    }

    /**
     * Supports the registration of ignored, tagged, pending tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" taggedAs(SlowTest) is (pending)
     *                                                                        ^
     *

     *
     *

     * Note: this is method is provided for completeness and design symmetry, given there's no way
     * to prevent changing is to ignore and marking a pending test as ignored that way.
     * Although it isn't clear why someone would want to mark a pending test as ignored, it can be done.
     *

     *
     *

     * For examples of pending test registration, see the Pending tests section in the main documentation
     * for trait FlatSpec.  For examples of the registration of ignored tests,
     * see the Ignored tests section
     * in the main documentation for trait FlatSpec. For examples of tagged test registration, see
     * the Tagging tests section in the main documentation for trait FlatSpec.
     *

     */
    def is(testFun: => PendingNothing) {
      registerTestToIgnore(verb.trim + " " + name.trim, tags, "is", unusedFixtureParam => testFun)
    }
  }

  /**
   * Class that supports registration of ignored tests via the IgnoreWord instance referenced
   * from fixture.FlatSpec's ignore field.
   *
   *

   * This class enables syntax such as the following registration of an ignored test:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" in { ... }
   *                                                       ^
   *

   *
   *

   * In addition, it enables syntax such as the following registration of an ignored, pending test:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" is (pending)
   *                                                       ^
   *

   *
   * Note: the is method is provided for completeness and design symmetry, given there's no way
   * to prevent changing is to ignore and marking a pending test as ignored that way.
   * Although it isn't clear why someone would want to mark a pending test as ignored, it can be done.
   *

   *
   *

   * And finally, it also enables syntax such as the following ignored, tagged test registration:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
   *                                                       ^
   *

   *
   *

   *

   * For more information and examples of the use of the ignore field, see the Ignored tests section
   * in the main documentation for trait FlatSpec.
   *

   */
  protected final class IgnoreVerbString(verb: String, name: String) {

    /**
     * Supports the registration of ignored, no-arg tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" in { () => ... }
     *                                                     ^
     *

     *
     *

     * For examples of the registration of ignored tests, see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored, one-arg tests (tests that take a FixtureParam object
     * as a parameter) in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" in { fixture => ... }
     *                                                     ^
     *

     *
     *

     * For examples of the registration of ignored tests, see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "in", testFun)
    }

    /**
     * Supports the registration of ignored, pending tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" is (pending)
     *                                                     ^
     *

     *
     *

     * Note: this is method is provided for completeness and design symmetry, given there's no way
     * to prevent changing is to ignore and marking a pending test as ignored that way.
     * Although it isn't clear why someone would want to mark a pending test as ignored, it can be done.
     *

     *
     *

     * For examples of pending test registration, see the Pending tests section in the main documentation
     * for trait FlatSpec.  For examples of the registration of ignored tests,
     * see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def is(testFun: => PendingNothing) {
      registerTestToIgnore(verb.trim + " " + name.trim, List(), "is", unusedFixtureParam => testFun)
    }

    /**
     * Supports the registration of ignored, tagged tests in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" taggedAs(SlowTest) in { ... }
     *                                                     ^
     *

     *
     *

     * For examples of tagged test registration, see the Tagging tests section in the main documentation
     * for trait FlatSpec.  For examples of the registration of ignored tests,
     * see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
      val tagList = firstTestTag :: otherTestTags.toList
      new IgnoreVerbStringTaggedAs(verb, name, tagList)
    }
  }

  /**
   * Class that supports registration of ignored tests via the instance referenced from fixture.FlatSpec's ignore field.
   *
   *

   * This class enables syntax such as the following registration of an ignored test:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" in { ... }
   * ^
   *

   *
   *

   * For more information and examples of the use of the ignore field, see Ignored tests section
   * in the main documentation for this trait.
   *

   */
  protected final class IgnoreWord {

    /**
     * Supports the registration of ignored tests with should in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore should "pop values in last-in-first-out order" in { ... }
     *        ^
     *

     *
     *

     * For more information and examples of the use of the ignore field, see Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def should(string: String) = new IgnoreVerbString("should", string)

    /**
     * Supports the registration of ignored tests with must in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore must "pop values in last-in-first-out order" in { ... }
     *        ^
     *

     *
     *

     * For more information and examples of the use of the ignore field, see Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def must(string: String) = new IgnoreVerbString("must", string)

    /**
     * Supports the registration of ignored tests with can in a fixture.FlatSpec.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * ignore can "pop values in last-in-first-out order" in { ... }
     *        ^
     *

     *
     *

     * For more information and examples of the use of the ignore field, see Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def can(string: String) = new IgnoreVerbString("can", string)
  }

  /**
   * Supports registration of ignored tests in fixture.FlatSpecs.
   *
   *

   * This field enables syntax such as the following registration of an ignored test:
   *

   *
   *

   * ignore should "pop values in last-in-first-out order" in { ... }
   * ^
   *

   *
   *

   * For more information and examples of the use of the ignore field, see the
   * Ignored tests section in the main documentation for trait FlatSpec.
   *

   */
  protected val ignore = new IgnoreWord

  /**
   * Class that supports test registration in shorthand form.
   *
   *

   * For example, this class enables syntax such as the following test registration
   * in shorthand form:
   *

   *
   *

   * "A Stack (when empty)" should "be empty" in { ... }
   *                                          ^
   *

   *
   *

   * This class also enables syntax such as the following ignored test registration
   * in shorthand form:
   *

   *
   *

   * "A Stack (when empty)" should "be empty" ignore { ... }
   *                                          ^
   *

   *
   *

   * This class is used via an implicit conversion (named convertToInAndIgnoreMethods)
   * from ResultOfStringPassedToVerb. The ResultOfStringPassedToVerb class
   * does not declare any methods named in, because the
   * type passed to in differs in a FlatSpec and a org.scalatest.fixture.FlatSpec.
   * A org.scalatest.fixture.FlatSpec needs two in methods, one that takes a no-arg
   * test function and another that takes a one-arg test function (a test that takes a
   * FixtureParam as its parameter). By constrast, a FlatSpec needs
   * only one in method that takes a by-name parameter. As a result,
   * FlatSpec and org.scalatest.fixture.FlatSpec each provide an implicit conversion
   * from ResultOfStringPassedToVerb to a type that provides the appropriate
   * in methods.
   *

   *
   * @author Bill Venners
   */
  protected final class InAndIgnoreMethods(resultOfStringPassedToVerb: ResultOfStringPassedToVerb) {

    import resultOfStringPassedToVerb.verb
    import resultOfStringPassedToVerb.rest

    /**
     * Supports the registration of no-arg tests in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" in { () => ... }
     *                                                        ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait fixture.FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToRun(verb.trim + " " + rest.trim, List(), "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of ignored, no-arg tests in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" ignore { () => ... }
     *                                                        ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + rest.trim, List(), "ignore", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of one-arg tests (tests that take a FixtureParam parameter) in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" in { fixture => ... }
     *                                                        ^
     *

     *
     *

     * For examples of test registration, see the main documentation
     * for trait fixture.FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToRun(verb.trim + " " + rest.trim, List(), "in", testFun)
    }

    /**
     * Supports the registration of ignored, one-arg tests (tests that take a FixtureParam parameter) in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" ignore { fixture => ... }
     *                                                        ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + rest.trim, List(), "ignore", testFun)
    }
  }

  /**
   * Implicitly converts an object of type ResultOfStringPassedToVerb to an
   * InAndIgnoreMethods, to enable in and ignore
   * methods to be invokable on that object.
   */
  protected implicit def convertToInAndIgnoreMethods(resultOfStringPassedToVerb: ResultOfStringPassedToVerb) =
    new InAndIgnoreMethods(resultOfStringPassedToVerb)

  /**
   * Class that supports tagged test registration in shorthand form.
   *
   *

   * For example, this class enables syntax such as the following tagged test registration
   * in shorthand form:
   *

   *
   *

   * "A Stack (when empty)" should "be empty" taggedAs() in { ... }
   *                                                     ^
   *

   *
   *

   * This class also enables syntax such as the following tagged, ignored test registration
   * in shorthand form:
   *

   *
   *

   * "A Stack (when empty)" should "be empty" taggedAs(SlowTest) ignore { ... }
   *                                                             ^
   *

   *
   *

   * This class is used via an implicit conversion (named convertToInAndIgnoreMethodsAfterTaggedAs)
   * from ResultOfTaggedAsInvocation. The ResultOfTaggedAsInvocation class
   * does not declare any methods named in, because the
   * type passed to in differs in a FlatSpec and a fixture.FlatSpec.
   * A fixture.FlatSpec needs two in methods, one that takes a no-arg
   * test function and another that takes a one-arg test function (a test that takes a
   * FixtureParam as its parameter). By constrast, a FlatSpec needs
   * only one in method that takes a by-name parameter. As a result,
   * FlatSpec and fixture.FlatSpec each provide an implicit conversion
   * from ResultOfTaggedAsInvocation to a type that provides the appropriate
   * in methods.
   *

   *
   * @author Bill Venners
   */
  protected final class InAndIgnoreMethodsAfterTaggedAs(resultOfTaggedAsInvocation: ResultOfTaggedAsInvocation) {

    import resultOfTaggedAsInvocation.verb
    import resultOfTaggedAsInvocation.rest
    import resultOfTaggedAsInvocation.{tags => tagsList}

    /**
     * Supports the registration of tagged, no-arg tests in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" taggedAs(SlowTest) in { () => ... }
     *                                                                           ^
     *

     *
     *

     * For examples of tagged test registration, see the Tagging tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: () => Any) {
      registerTestToRun(verb.trim + " " + rest.trim, tagsList, "in", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of tagged, ignored, no-arg tests in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { () => ... }
     *                                                                           ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     * For examples of tagged test registration, see the Tagging tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: () => Any) {
      registerTestToIgnore(verb.trim + " " + rest.trim, tagsList, "ignore", new NoArgTestWrapper(testFun))
    }

    /**
     * Supports the registration of tagged, one-arg tests (tests that take a FixtureParam parameter) in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" taggedAs(SlowTest) in { fixture => ... }
     *                                                                           ^
     *

     *
     *

     * For examples of tagged test registration, see the Tagging tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def in(testFun: FixtureParam => Any) {
      registerTestToRun(verb.trim + " " + rest.trim, tagsList, "in", testFun)
    }

    /**
     * Supports the registration of tagged, ignored, one-arg tests (tests that take a FixtureParam parameter) in shorthand form.
     *
     *

     * This method supports syntax such as the following:
     *

     *
     *

     * "A Stack" must "pop values in last-in-first-out order" taggedAs(SlowTest) ignore { fixture => ... }
     *                                                                           ^
     *

     *
     *

     * For examples of ignored test registration, see the Ignored tests section
     * in the main documentation for trait FlatSpec.
     * For examples of tagged test registration, see the Tagging tests section
     * in the main documentation for trait FlatSpec.
     *

     */
    def ignore(testFun: FixtureParam => Any) {
      registerTestToIgnore(verb.trim + " " + rest.trim, tagsList, "ignore", testFun)
    }
  }

  /**
   * Implicitly converts an object of type ResultOfTaggedAsInvocation to an
   * InAndIgnoreMethodsAfterTaggedAs, to enable in and ignore
   * methods to be invokable on that object.
   */
  protected implicit def convertToInAndIgnoreMethodsAfterTaggedAs(resultOfTaggedAsInvocation: ResultOfTaggedAsInvocation) =
    new InAndIgnoreMethodsAfterTaggedAs(resultOfTaggedAsInvocation)

  /**
   * Supports the shorthand form of test registration.
   *
   *

   * For example, this method enables syntax such as the following:
   *

   *
   *

   * "A Stack (when empty)" should "be empty" in { ... }
   *                        ^
   *

   *
   *

   * This function is passed as an implicit parameter to a should method
   * provided in ShouldVerb, a must method
   * provided in MustVerb, and a can method
   * provided in CanVerb. When invoked, this function registers the
   * subject description (the first parameter to the function) and returns a ResultOfStringPassedToVerb
   * initialized with the verb and rest parameters (the second and third parameters to
   * the function, respectively).
   *

   */
  protected implicit val shorthandTestRegistrationFunction: (String, String, String) => ResultOfStringPassedToVerb = {
    (subject, verb, rest) => {
      registerFlatBranch(subject, "describeCannotAppearInsideAnIt", sourceFileName, "apply", 5, 0)
      new ResultOfStringPassedToVerb(verb, rest) {
        def is(testFun: => PendingNothing) {
          registerTestToRun(verb.trim + " " + rest.trim, List(), "is", unusedFixtureParam => testFun)
        }
        def taggedAs(firstTestTag: Tag, otherTestTags: Tag*) = {
          val tagList = firstTestTag :: otherTestTags.toList
          new ResultOfTaggedAsInvocation(verb, rest, tagList) {
            // "A Stack" must "test this" taggedAs(mytags.SlowAsMolasses) is (pending)
            //                                                            ^
            def is(testFun: => PendingNothing) {
              registerTestToRun(verb.trim + " " + rest.trim, tags, "is", new NoArgTestWrapper(testFun _))
            }
          }
        }
      }
    }
  }

  // TODO: Get rid of unusedfixture, and use NoArgTestFunction instead

  /**
   * Supports the shorthand form of shared test registration.
   *
   *

   * For example, this method enables syntax such as the following:
   *

   *
   *

   * "A Stack (with one item)" should behave like nonEmptyStack(stackWithOneItem, lastValuePushed)
   *                           ^
   *

   *
   *

   * This function is passed as an implicit parameter to a should method
   * provided in ShouldVerb, a must method
   * provided in MustVerb, and a can method
   * provided in CanVerb. When invoked, this function registers the
   * subject description (the  parameter to the function) and returns a BehaveWord.
   *

   */
  protected implicit val shorthandSharedTestRegistrationFunction: (String) => BehaveWord = {
    (left) => {
      registerFlatBranch(left, "describeCannotAppearInsideAnIt", sourceFileName, "apply", 5, 0)
      new BehaveWord
    }
  }

  /**
   * Register a test to ignore, which has the given spec text, optional tags, and test function value that takes no arguments.
   * This method will register the test for later ignoring via an invocation of one of the execute
   * methods. This method exists to make it easy to ignore an existing test by changing the call to it
   * to ignore without deleting or commenting out the actual test code. The test will not be executed, but a
   * report will be sent that indicates the test was ignored. The name of the test will be a concatenation of the text of all surrounding describers,
   * from outside in, and the passed spec text, with one space placed between each item. (See the documenation
   * for testNames for an example.) The resulting test name must not have been registered previously on
   * this FlatSpec instance.
   *
   * @param specText the specification text, which will be combined with the descText of any surrounding describers
   * to form the test name
   * @param testTags the optional list of tags for this test
   * @param methodName caller's method name
   * @param testFun the test function
   * @throws DuplicateTestNameException if a test with the same name has been registered previously
   * @throws TestRegistrationClosedException if invoked after run has been invoked on this suite
   * @throws NullPointerException if specText or any passed test tag is null
   */
  private def registerTestToIgnore(specText: String, testTags: List[Tag], methodName: String, testFun: FixtureParam => Any) {
    registerIgnoredTest(specText, Transformer(testFun), "ignoreCannotAppearInsideAnIt", sourceFileName, methodName, 4, -3, None, testTags: _*)
  }

  /**
   * A Map whose keys are String tag names to which tests in this FlatSpec belong, and values
   * the Set of test names that belong to each tag. If this fixture.FlatSpec contains no tags, this method returns an empty Map.
   *
   *

   * This trait's implementation returns tags that were passed as strings contained in Tag objects passed to
   * methods test and ignore.
   *

   *
   *

   * In addition, this trait's implementation will also auto-tag tests with class level annotations.
   * For example, if you annotate @Ignore at the class level, all test methods in the class will be auto-annotated with @Ignore.
   *

   */
  override def tags: Map[String, Set[String]] = autoTagClassAnnotations(atomic.get.tagsMap, this)

  /**
   * Run a test. This trait's implementation runs the test registered with the name specified by
   * testName. Each test's name is a concatenation of the text of all describers surrounding a test,
   * from outside in, and the test's  spec text, with one space placed between each item. (See the documenation
   * for testNames for an example.)
   *
   * @param testName the name of one test to execute.
   * @param reporter the Reporter to which results will be reported
   * @param stopper the Stopper that will be consulted to determine whether to stop execution early.
   * @param configMap a Map of properties that can be used by this FlatSpec's executing tests.
   * @throws NullPointerException if any of testName, reporter, stopper, or configMap
   *     is null.
   */
  protected override def runTest(testName: String, args: Args): Status = {

    def invokeWithFixture(theTest: TestLeaf): Outcome = {
      theTest.testFun match {
        case transformer: org.scalatest.fixture.Transformer[_] =>
          transformer.exceptionalTestFun match {
            case wrapper: NoArgTestWrapper[_] =>
              withFixture(new FixturelessTestFunAndConfigMap(testName, wrapper.test, args.configMap))
            case fun => withFixture(new TestFunAndConfigMap(testName, fun, args.configMap))
          }
        case other =>
          other match {
            case wrapper: NoArgTestWrapper[_] =>
              withFixture(new FixturelessTestFunAndConfigMap(testName, wrapper.test, args.configMap))
            case fun => withFixture(new TestFunAndConfigMap(testName, fun, args.configMap))
          }
      }
    }

    runTestImpl(thisSuite, testName, args, true, invokeWithFixture)
  }

  /**
   *

   * Run zero to many of this FlatSpec's tests.
   *

   *
   *

   * This method takes a testName parameter that optionally specifies a test to invoke.
   * If testName is Some, this trait's implementation of this method
   * invokes runTest on this object, passing in:
   *

   *
   *

   *
testName - the String value of the testName Option passed
   *   to this method

   *
reporter - the Reporter passed to this method, or one that wraps and delegates to it

   *
stopper - the Stopper passed to this method, or one that wraps and delegates to it

   *
configMap - the configMap passed to this method, or one that wraps and delegates to it

   *

   *
   *

   * This method takes a Set of tag names that should be included (tagsToInclude), and a Set
   * that should be excluded (tagsToExclude), when deciding which of this Suite's tests to execute.
   * If tagsToInclude is empty, all tests will be executed
   * except those those belonging to tags listed in the tagsToExclude Set. If tagsToInclude is non-empty, only tests
   * belonging to tags mentioned in tagsToInclude, and not mentioned in tagsToExclude
   * will be executed. However, if testName is Some, tagsToInclude and tagsToExclude are essentially ignored.
   * Only if testName is None will tagsToInclude and tagsToExclude be consulted to
   * determine which of the tests named in the testNames Set should be run. For more information on trait tags, see the main documentation for this trait.
   *

   *
   *

   * If testName is None, this trait's implementation of this method
   * invokes testNames on this Suite to get a Set of names of tests to potentially execute.
   * (A testNames value of None essentially acts as a wildcard that means all tests in
   * this Suite that are selected by tagsToInclude and tagsToExclude should be executed.)
   * For each test in the testName Set, in the order
   * they appear in the iterator obtained by invoking the elements method on the Set, this trait's implementation
   * of this method checks whether the test should be run based on the tagsToInclude and tagsToExclude Sets.
   * If so, this implementation invokes runTest, passing in:
   *

   *
   *

   *
testName - the String name of the test to run (which will be one of the names in the testNames Set)

   *
reporter - the Reporter passed to this method, or one that wraps and delegates to it

   *
stopper - the Stopper passed to this method, or one that wraps and delegates to it

   *
configMap - the configMap passed to this method, or one that wraps and delegates to it

   *

   *
   * @param testName an optional name of one test to execute. If None, all relevant tests should be executed.
   *                 I.e., None acts like a wildcard that means execute all relevant tests in this FlatSpec.
   * @param args the Args for this run
   *
   * @throws NullPointerException if any of testName, reporter, stopper, tagsToInclude,
   *     tagsToExclude, or configMap is null.
   */
  protected override def runTests(testName: Option[String], args: Args): Status = {
    runTestsImpl(thisSuite, testName, args, info, true, runTest)
  }

  /**
   * An immutable Set of test names. If this fixture.FlatSpec contains no tests, this method returns an
   * empty Set.
   *
   *

   * This trait's implementation of this method will return a set that contains the names of all registered tests. The set's
   * iterator will return those names in the order in which the tests were registered. Each test's name is composed
   * of the concatenation of the text of each surrounding describer, in order from outside in, and the text of the
   * example itself, with all components separated by a space.
   *

   */
  override def testNames: Set[String] = {
    // I'm returning a ListSet here so that they tests will be run in registration order
    ListSet(atomic.get.testNamesList.toArray: _*)
  }

  override def run(testName: Option[String], args: Args): Status = {
   runImpl(thisSuite, testName, args, super.run)
  }

  /**
   * Supports shared test registration in fixture.FlatSpecs.
   *
   *

   * This field supports syntax such as the following:
   *

   *
   *

   * it should behave like nonFullStack(stackWithOneItem)
   *           ^
   *

   *
   *

   * For more information and examples of the use of behave, see the Shared tests section
   * in the main documentation for trait FlatSpec.
   *

   */
  protected val behave = new BehaveWord

  /**
   * Suite style name.
   */
  final override val styleName: String = "org.scalatest.fixture.FlatSpec"

  override def testDataFor(testName: String, theConfigMap: ConfigMap = ConfigMap.empty): TestData = createTestDataFor(testName, theConfigMap, this)
}


text:
<?php

declare(strict_types=1);

namespace AdminPanel\Symfony\AdminBundle\Admin\CRUD;

use AdminPanel\Symfony\AdminBundle\Exception\RequestHandlerException;

interface DeleteElement extends BatchElement
{
    /**
     * @throws RequestHandlerException - when cannot apply delete operation to given index ex. element is not found
     * @param mixed $index
     */
    public function delete($index);
}

redpajama_set_name: RedPajamaGithub


text:
<?php
/**
* Auto generated from AcquireCounteragent.proto
*
 * Diadoc.Api.Proto package
 */

namespace Diadoc\Api\Proto {
/**
 * InvitationDocument message
 */
class InvitationDocument extends \ProtobufMessage
{
    /* Field index constants */
    const SIGNEDCONTENT = 1;
    const FILENAME = 2;
    const SIGNATUREREQUESTED = 3;
    const TYPE = 4;

    /* @var array Field descriptors */
    protected static $fields = array(
        self::SIGNEDCONTENT => array(
            'name' => 'SignedContent',
            'required' => true,
            'type' => '\Diadoc\Api\Proto\Events\SignedContent'
        ),
        self::FILENAME => array(
            'name' => 'FileName',
            'required' => true,
            'type' => \ProtobufMessage::PB_TYPE_STRING,
        ),
        self::SIGNATUREREQUESTED => array(
            'default' => false,
            'name' => 'SignatureRequested',
            'required' => false,
            'type' => \ProtobufMessage::PB_TYPE_BOOL,
        ),
        self::TYPE => array(
            'name' => 'Type',
            'required' => false,
            'type' => \ProtobufMessage::PB_TYPE_STRING,
        ),
    );

    /**
     * Constructs new message container and clears its internal state
     */
    public function __construct()
    {
        $this->reset();
    }

    /**
     * Clears message values and sets default ones
     *
     * @return null
     */
    public function reset()
    {
        $this->values[self::SIGNEDCONTENT] = null;
        $this->values[self::FILENAME] = null;
        $this->values[self::SIGNATUREREQUESTED] = self::$fields[self::SIGNATUREREQUESTED]['default'];
        $this->values[self::TYPE] = null;
    }

    /**
     * Returns field descriptors
     *
     * @return array
     */
    public function fields()
    {
        return self::$fields;
    }

    /**
     * Sets value of 'SignedContent' property
     *
     * @param \Diadoc\Api\Proto\Events\SignedContent $value Property value
     *
     * @return null
     */
    public function setSignedContent(\Diadoc\Api\Proto\Events\SignedContent $value=null)
    {
        return $this->set(self::SIGNEDCONTENT, $value);
    }

    /**
     * Returns value of 'SignedContent' property
     *
     * @return \Diadoc\Api\Proto\Events\SignedContent
     */
    public function getSignedContent()
    {
        return $this->get(self::SIGNEDCONTENT);
    }

    /**
     * Sets value of 'FileName' property
     *
     * @param string $value Property value
     *
     * @return null
     */
    public function setFileName($value)
    {
        return $this->set(self::FILENAME, $value);
    }

    /**
     * Returns value of 'FileName' property
     *
     * @return string
     */
    public function getFileName()
    {
        $value = $this->get(self::FILENAME);
        return $value === null ? (string)$value : $value;
    }

    /**
     * Sets value of 'SignatureRequested' property
     *
     * @param boolean $value Property value
     *
     * @return null
     */
    public function setSignatureRequested($value)
    {
        return $this->set(self::SIGNATUREREQUESTED, $value);
    }

    /**
     * Returns value of 'SignatureRequested' property
     *
     * @return boolean
     */
    public function getSignatureRequested()
    {
        $value = $this->get(self::SIGNATUREREQUESTED);
        return $value === null ? (boolean)$value : $value;
    }

    /**
     * Sets value of 'Type' property
     *
     * @param string $value Property value
     *
     * @return null
     */
    public function setType($value)
    {
        return $this->set(self::TYPE, $value);
    }

    /**
     * Returns value of 'Type' property
     *
     * @return string
     */
    public function getType()
    {
        $value = $this->get(self::TYPE);
        return $value === null ? (string)$value : $value;
    }
}
}


text:
<?xml version="1.0" encoding="UTF-8"?>

<chapter version="5.0" xml:id="KIM_Group" xmlns="http://docbook.org/ns/docbook"
    xmlns:xlink="http://www.w3.org/1999/xlink">
    <title>Group</title>

      <title>Group Lookup Screen</title>
      <para>The Group Lookup function provides a quick reference to key Group
      information.</para>

      <para>You get to this screen by clicking the <emphasis
      role="bold">Group</emphasis> option in the <emphasis
      role="bold">Identity</emphasis> section of the <emphasis
      role="bold">Administration</emphasis> screen.</para>

        <title>Identity Channel: Group Link</title>

        <mediaobject>
          <imageobject>
            <imagedata fileref="../images/select_group_new.png" width="100%" scalefit="1"/>
          </imageobject>
        </mediaobject>

        <title>Group Lookup</title>

        <mediaobject>
          <imageobject>
            <imagedata fileref="../images/group_lookup_new.png" width="100%" scalefit="1"/>
          </imageobject>
        </mediaobject>

      <para>On the <emphasis role="bold">Group Lookup</emphasis> screen, click
      the <emphasis role="bold">create new</emphasis> button to go to the
      <emphasis role="bold">Group Maintenance</emphasis> screen, where you can
      create a new Group in Rice.</para>

      <para>Conducting a search from the Group Lookup screen returns a list
      similar to this:</para>

        <title>Group Lookup: Results</title>

        <mediaobject>
          <imageobject>
            <imagedata fileref="../images/group_lookup_results_new.png" width="100%" scalefit="1"/>
          </imageobject>
        </mediaobject>

      <para>For information on any of the fields above, please refer to the
      <emphasis role="bold">Group Maintenance</emphasis> section below.</para>

      <title>Group Inquiry Screen</title>

      <para>This screen provides high-level information about a Group and
      shows who is assigned to it.</para>

      <para>Click a <emphasis role="bold">Group Request</emphasis> value on
      the <emphasis role="bold">Action List</emphasis> screen to display the
      <emphasis role="bold">Group Inquiry</emphasis> page for that
      Group:</para>

        <title>Group Inquiry</title>

        <mediaobject>
          <imageobject>
            <imagedata fileref="../images/group_inquiry_new.png" width="100%" scalefit="1"/>
          </imageobject>
        </mediaobject>

        <title>Overview Tab</title>

        <para>For information on these fields please refer to the <emphasis
        role="bold">Group Maintenance</emphasis> section that follows.</para>

        <title>Assignees Tab</title>

        <para>

            <title>Group Inquiry: Assignees Attributes</title>
            <tgroup cols="2">
              <colspec colname="c1" colnum="1" colwidth="0.5*"/>
              <colspec colname="c2" colnum="2" colwidth="1.0*"/>

                <row>
                  <entry>Field</entry>
                  <entry>Description</entry>
                </row>

                <row>
                  <entry>Type Code</entry>
                  <entry>The code for the type of this Group member</entry>
                </row>
                <row>
                  <entry>Member Identifier</entry>
                  <entry>The user ID for the Member</entry>
                </row>
                <row>
                  <entry>Name</entry>
                  <entry>The user name for the Member</entry>
                </row>
                <row>
                  <entry>Active From Dt</entry>

                  <entry>The effective date of membership in this Group for
                  this member; if it is blank, membership is valid as soon as
                  the member is assigned This field is useful when you want to
                  add a Person, Role, or Group to a Group before he/she/they
                  should be active in the Group. This might happen, for
                  example, when you add a new employee before their start
                  date.</entry>
                </row>
                <row>
                  <entry>Active To Dt</entry>

                  <entry>The termination date of membership for this member;
                  if blank, the membership does not terminate</entry>
                </row>

            </tgroup>

</para>

      <title>Group Maintenance Document</title>

      <para>The Group document allows you to associate Persons, Roles, or
      other Groups with each other so you can assign the same role to all
      Group members.</para>

      <para>Groups have no inherent permissions or responsibilities of their
      own. Only by associating a Group with a role do the members of that
      Group become associated with permissions and responsibilities.</para>

        <title>Creating New Groups</title>

        <para>If you are creating a new Group and have clicked the <emphasis role="bold">Create
          New</emphasis> button on the Group Lookup screen, you will be redirected to the Group
        creation page. One of the first things to do, if wanting to create a group with a
        non-default Group Type, is to use the kim type lookup to select a different group type. Once
        you click on the Type Name in the Overview tab, you will be redirected to a screen like the
        following:</para>

          <title>KIM Type Lookup</title>

          <mediaobject>
            <imageobject>
              <imagedata fileref="../images/Kim_type_lookup_new.png" width="100%" scalefit="1"/>
            </imageobject>
          </mediaobject>

        <para>

            <title>KIM Type Lookup Search Attributes</title>
            <tgroup cols="2">
              <colspec colname="c1" colnum="1" colwidth="0.5*"/>
              <colspec colname="c2" colnum="2" colwidth="1.0*"/>

                <row>
                  <entry>Field</entry>
                  <entry>Description</entry>
                </row>

                <row>
                  <entry>Namespace Code</entry>

                  <entry>Optional. Select the code for the application and
                  module to which this KIM Type pertains.</entry>
                </row>
                <row>
                  <entry>Type Name</entry>
                  <entry>Optional. Enter the name for this KIM Type.</entry>
                </row>
                <row>
                  <entry>Type Identifier</entry>

                  <entry>Optional. Enter the unique system-assigned Identifier
                  for this KIM Type.</entry>
                </row>
                <row>
                  <entry>Active Indicator</entry>

                  <entry>Required (defaults to Yes). Change the default
                  selection to view KIM types that are inactive or to see all
                  Types (active and inactive).</entry>
                </row>

            </tgroup>

</para>

        <para><emphasis role="bold">The search results list includes the same
        fields as the Lookup screen. </emphasis>The search results are
        displayed below the search fields on the Lookup screen.</para>

        <para>To select the Type you want to use for your new Group, click the
        return value link for that Type. KIM will copy the Type information to
        use in creating your new Group.</para>

        <title>Group Maintenance Document: Layout</title>
        <para>The Group document includes these tabs:<itemizedlist>
            <listitem>
              <para>Document Overview</para>
            </listitem>
            <listitem>
              <para>Overview</para>
            </listitem>
            <listitem>
              <para>Assignees</para>
            </listitem>
            <listitem>
              <para>Ad Hoc Recipients</para>
            </listitem>
            <listitem>
              <para>Route Log</para>
            </listitem>
          </itemizedlist></para>

        <para>The Overview and Assignees tabs are described below. Information
        on the Ad Hoc Recipients and Route Log tabs can be found in the
          <link xlink:href="http://site.kuali.org/rice/${project.version}/reference/html/Intro_To_Rice.html#frequent_tab">Frequently Used Tabs</link>
        section of the Introduction to Rice Guide.</para>

          <title>Group Maintenance Document</title>

          <mediaobject>
            <imageobject>
              <imagedata fileref="../images/group_maintenance_document_new.png" width="100%" scalefit="1"/>
            </imageobject>
          </mediaobject>

          <title>Overview Tab</title>

          <para>This tab identifies the Group with a unique system-assigned ID
          number, a namespace, and a name. Each Group also has a Type that
          specifies any qualifiers that this Group might require.</para>

            <title>Group Maintenance Document: Group Overview</title>

            <mediaobject>
              <imageobject>
                <imagedata fileref="../images/group_overview_new.png" width="100%" scalefit="1"/>
              </imageobject>
            </mediaobject>

          <para>

              <title>Group Maintenance Document: Group Overview
              Attributes</title>

              <tgroup cols="2">
                <colspec colname="c1" colnum="1" colwidth="0.5*"/>
                <colspec colname="c2" colnum="2" colwidth="1.0*"/>

                  <row>
                    <entry>Field</entry>
                    <entry>Description</entry>
                  </row>

                  <row>
                    <entry>Group ID</entry>
                    <entry>Display-only. The unique system-assigned ID number
                    that identifies this Group; Rice completes this field when
                    you submit the document.</entry>
                  </row>
                  <row>
                    <entry>Type Name</entry>

                    <entry><para>Required. The type of attributes that are
                    associated with this Group. Some Group types, such as the
                    Default Type, do not require attributes.</para>
                    <para><emphasis role="bold">Note: </emphasis>When creating
                    a new Group, you must select the Type before Rice can
                    generate the document. See the Creating New Groups section
                    of this document</para></entry>
                  </row>
                  <row>
                    <entry>Group Namespace</entry>

                    <entry>Required. An indicator that associates the Group
                    with a particular application and module</entry>
                  </row>
                  <row>
                    <entry>Group Name</entry>
                    <entry>Required. The common descriptive name by which this
                    Group is known</entry>
                  </row>
                  <row>
                    <entry>Active</entry>

                    <entry>Check this box to indicate that this Group is
                    active and is a valid choice for assigning to roles.
                    Uncheck the box to indicate that this Group is inactive
                    (it is no longer valid when making role
                    assignments).</entry>
                  </row>
                  <row>
                    <entry>Group Description</entry>

                    <entry>Optional. Some text to describe the group.</entry>
                  </row>

              </tgroup>

</para>

          <title>Assignees Tab</title>

          <para>This tab displays the members who belong to this Group. You
          can also use this tab to add new members or to edit the fields for
          existing members.</para>

          <para>Note that for members not added to the group on this
          maintenance document, the "delete" button to remove that member is
          inactive. If a member's association with a group is past, users
          should set the "Active To Date" field to the end of the membership;
          the member will not be an active member of the group after that
          date.</para>

            <title>Group Maintenance Document: Assignees Tab</title>

            <mediaobject>
              <imageobject>
                <imagedata fileref="../images/assignees_tab_new.png" width="100%" scalefit="1"/>
              </imageobject>
            </mediaobject>

          <para>

              <title>Group Maintenance Document: Assignees Tab
              Attributes</title>

              <tgroup cols="2">
                <colspec colname="c1" colnum="1" colwidth="0.5*"/>
                <colspec colname="c2" colnum="2" colwidth="1.0*"/>

                  <row>
                    <entry>Field Name</entry>
                    <entry>Description</entry>
                  </row>

                  <row>
                    <entry>Type Code</entry>
                    <entry>Required. Select the Type of the member you are
                    adding to this Group. Group members can be Principals (as
                    defined on the Person document), Roles, or other
                    Groups.</entry>
                  </row>
                  <row>
                    <entry>Member Identifier</entry>

                    <entry>Required. Enter the ID that identifies the member
                    you are adding, or use the lookup to search for and select
                    a valid Member ID. The lookup directs you to the <emphasis
                    role="bold">Principal</emphasis>, <emphasis
                    role="bold">Group</emphasis>, or <emphasis
                    role="bold">Role</emphasis> lookup, based on your
                    <emphasis role="bold">Member Type Code</emphasis>
                    selection.</entry>
                  </row>
                  <row>
                    <entry>Name</entry>

                    <entry>Optional. Enter the person name. Clicking on the magnifying glass icon
                    brings up the Person Lookup screen, where a person may be looked up and, once
                    located, inserted.</entry>
                  </row>
                  <row>
                    <entry>Active From Date</entry>

                    <entry>Optional. To specify the earliest date on which
                    this member is to be considered a valid member of this
                    Group, enter a date in this field.</entry>
                  </row>
                  <row>
                    <entry>Active To Date</entry>

                    <entry><para>Optional. To specify a date on which this
                    member is no longer to be considered a valid member of
                    this Group, enter a date in this field. As of this date,
                    the Member will no longer be considered a member of this
                    Group.</para> <para><emphasis role="bold">Note:
                    </emphasis>You cannot delete or inactivate Group members.
                    To remove a member from a Group, enter an Active To
                    Date.</para></entry>
                  </row>
                  <row>
                    <entry>Actions</entry>

                    <entry>Click the <emphasis role="bold">Add</emphasis>
                    button to add this member to the Group.</entry>
                  </row>

              </tgroup>

</para>

</chapter>


text:
Tips
====

The toolbar isn't displayed!
----------------------------

The Debug Toolbar will only display when ``DEBUG = True`` in your project's
settings. It will also only display if the mimetype of the response is
either ``text/html`` or ``application/xhtml+xml`` and contains a closing
``</body>`` tag.

Be aware of middleware ordering and other middleware that may intercept
requests and return responses. Putting the debug toolbar middleware *after*
the Flatpage middleware, for example, means the toolbar will not show up on
flatpages.

Middleware isn't working correctly
----------------------------------

Using the Debug Toolbar in its default configuration and with the profiling
panel will cause middlewares after
``debug_toolbar.middleware.DebugToolbarMiddleware`` to not execute their
``process_view`` functions. This can be resolved by disabling the profiling
panel or moving the ``DebugToolbarMiddleware`` to the end of
``MIDDLEWARE_CLASSES``. Read more about it at
:ref:`ProfilingPanel <profiling-panel>`

Using the toolbar offline
-------------------------

The Debug Toolbar loads the jQuery_ library from the Google Hosted Libraries
CDN. Your browser will keep it in cache, allowing you to use the toolbar even
if you disconnect from the Internet temporarily.

If you want to use the Debug Toolbar without an Internet connection at all, or
if you refuse to depend on Google's services, look at the ``JQUERY_URL``
configuration option.

.. _jQuery: http://jquery.com/

Performance considerations
--------------------------

The Debug Toolbar is designed to introduce as little overhead as possible in
the rendering of pages. However, depending on your project, the overhead may
become noticeable. In extreme cases, it can make development impractical.
Here's a breakdown of the performance issues you can run into and their
solutions.

Problems
~~~~~~~~

The Debug Toolbar works in two phases. First, it gathers data while Django
handles a request and stores this data in memory. Second, when you open a
panel in the browser, it fetches the data on the server and displays it.

If you're seeing excessive CPU or memory consumption while browsing your site,
you must optimize the "gathering" phase. If displaying a panel is slow, you
must optimize the "rendering" phase.

Culprits
~~~~~~~~

The SQL panel may be the culprit if your view performs many SQL queries. You
should attempt to minimize the number of SQL queries, but this isn't always
possible, for instance if you're using a CMS and have disabled caching for
development.

The cache panel is very similar to the SQL panel, except it isn't always a bad
practice to make many cache queries in a view.

The template panel becomes slow if your views or context processors return large
contexts and your templates have complex inheritance or inclusion schemes.

Solutions
~~~~~~~~~

If the "gathering" phase is too slow, you can disable problematic panels
temporarily by deselecting the checkbox at the top right of each panel. That
change will apply to the next request. If you don't use some panels at all,
you can remove them permanently by customizing the ``DEBUG_TOOLBAR_PANELS``
setting.

By default, data gathered during the last 10 requests is kept in memory. This
allows you to use the toolbar on a page even if you have browsed to a few
other pages since you first loaded that page. You can reduce memory
consumption by setting the ``RESULTS_CACHE_SIZE`` configuration option to a
lower value. At worst, the toolbar will tell you that the data you're looking
for isn't available anymore.

If the "rendering" phase is too slow, refrain from clicking on problematic
panels :) Or reduce the amount of data gathered and rendered by these panels
by disabling some configuration options that are enabled by default:

- ``ENABLE_STACKTRACES`` for the SQL and cache panels,
- ``SHOW_TEMPLATE_CONTEXT`` for the template panel.


text:
namespace google {
namespace cloud {
namespace retail {
GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN

PredictionServiceClient::PredictionServiceClient(
    std::shared_ptr<PredictionServiceConnection> connection, Options opts)
    : connection_(std::move(connection)),
      options_(
          internal::MergeOptions(std::move(opts), connection_->options())) {}
PredictionServiceClient::~PredictionServiceClient() = default;

StatusOr<google::cloud::retail::v2::PredictResponse>
PredictionServiceClient::Predict(
    google::cloud::retail::v2::PredictRequest const& request, Options opts) {
  internal::OptionsSpan span(internal::MergeOptions(std::move(opts), options_));
  return connection_->Predict(request);
}

GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
}  // namespace retail
}  // namespace cloud
}  // namespace google


text:
请先在编辑器中点击定位,然后开始上传。(你也可以 使用传统方式上传)

<input id="file_upload" name="file_upload" type="file" />

<link href="~js/uploadify/uploadify.css" type="text/css" rel="stylesheet" />


text:
<!doctype html>

    <meta charset="utf-8" />
    <meta content="IE=edge;chrome=1" http-equiv="X-UA-Compatible" />
    <title>dognews</title>
    <meta content="width=device-width, initial-scale=1" name="viewport" />
    <link rel="alternate" type="application/atom+xml" title="Atom Feed" href="/feed.xml" /><link href="../../css/all.css" media="screen" rel="stylesheet" type="text/css" />
    <link href="/favicon.png" rel="icon" type="image/png" />

          <button class="navbar-toggle collapsed" data-target=".navbar-ex1-collapse" data-toggle="collapse" type="button">Toggle navigation</button>dognews

               Über Uns

               Newsletter!

              Categories

                  businessidee (38)

                  deutschland (596)

                  erziehung (35)

                  fotografie (5)

                  freizeit (83)

                  gesetz (38)

                  gesundheit (116)

                  herdenhunde (10)

                  hundesachkunde (13)

                  hundesport (12)

                  kinder (9)

                  kurioses (29)

                  oesterreich (63)

                  rassen (8)

                  ratgeber (161)

                  rettungshunde (3)

                  schweiz (99)

                  senioren (10)

                  stars (11)

                  urlaub (39)

                  veranstaltung (1)

                  wandern (17)

                  wissen (200)

              By Year

                  2017 (8)

                  2016 (55)

                  2015 (458)

                  2014 (273)

            Archive for 2014

            Page 7 of 28

            Previous page

              Futtern wie die Menschen

              deutschland
              wissen

               Posted on Nov 21

<dummy>      Futtern wie die Menschen Was für mich gut ist, kann für meinen Hund nicht schlecht sein." Nach diesem Motto handelten viele Tierbesitzer, sagt Detlev Nolte, Sprecher des Industrieverbands Heimtierbedarf (IVH).Wer etwa seine Ernährung...</dummy>

Read More

              Hundeflüsterin: Hunde werden zu sehr vermenschlicht

              deutschland
              freizeit

               Posted on Nov 20

<dummy>      Maike Maja Nowak (52) ist die Hundeflüsterin: Am Donnerstag kommt sie nach München, um aus ihrem neusten Buch vorzulesen. Darin geht es um ihre Begegnungen mit Hunden und die ganz besondere Beziehung zwischen den Beiden.
                Link</dummy>

               ...

Read More

              Herrchen haften für ihre Hunde

              deutschland
              gesetz

               Posted on Nov 20

<dummy>      An der Musikschule im Holdereggenpark hat eine englische Bulldogge einen vierjährigen Jungen angesprungen. Die Mutter des Jungen fragt sich jetzt, ob es nicht möglich ist, den Holdereggenpark entweder hundefrei zu halten oder eine Leinenpflicht...</dummy>

Read More

              Hundetipp des Monats: Gesund und fit durch den November

              ratgeber
              deutschland

               Posted on Nov 20

<dummy>      Fellwechsel, Wind und Regen sowie Spaziergänge bei Dunkelheit: Für Hunde und ihre Halter bringt der Herbst einige Herausforderungen. Wenn ein par Tipps beachtet werden, können Hund und Halter im Herbst viel Spaß haben.
                Link</dummy>

            ...

Read More

              Bunte Hunde / Spot the Dog

              deutschland
              freizeit

               Posted on Nov 19

<dummy>      "Wenn Du einen Freund willst, schaff Dir einen Hund an", sagte schon Harry Truman und sprach damit nicht nur Politikern und Bankern aus der Seele. Hunde sind in fast jeder Beziehung die besseren Menschen: treuer, manierlicher, ehrlicher...</dummy>

Read More

              Erste Hilfe am Hund: Wormser ASB vermittelt Tipps wie man im Notfall helfen kann

              deutschland
              wissen

               Posted on Nov 19

<dummy>      Allerdings haben die Wormser ASBler am Wochenende ihr Lehrgangsangebot erweitert und sich dazu entschieden, einen ganz speziellen Erste-Hilfe-Kurs anzubieten. Im Leiselheimer Dienstleistungszentrum des ASB, wo für gewöhnlich größtenteils...</dummy>

Read More

              Die Hunde sind los

              schweiz
              hundesport

               Posted on Nov 19

<dummy>      Die Musher (Schlittenhundeführer) stehen mit drei- bis vierrädrigen Wagen und ihrem Hundegespann am Start beim Asperhof in Thalheim. Dann fällt der Startschuss und das erste Achtergespann macht sich auf die 6.5 Kilometer lange Strecke...</dummy>

Read More

              Dogs on Instagram versus Reality: 12 Beispiele, warum Hunde sich im echten Leben nie wie auf ...

              deutschland
              freizeit

               Posted on Nov 18

<dummy>      Apps Dogs on Instagram versus Reality: 12 Beispiele, warum Hunde sich im echten Leben nie wie auf Instagram-Fotos benehmen Euer Hund benimmt sich auch nie wie die Vorzeigehunde, die wir jeden Tag auf Instagram vorgesetzt bekommen? Willkommen...</dummy>

Read More

              Besser als allein : Ein Hund ist der beste Freund des Läufers

              deutschland
              freizeit

               Posted on Nov 18

<dummy>      Ein Hund ist der beste Freund des Läufers Unser Autor ist Kommunikationsberater, fing an zu laufen und nahm in 18 Monaten mehr als 40 Kilo ab. Immer montags schreibt er über seine Leidenschaft. Heute: Warum der Hund zum Laufen dazu geh...</dummy>

Read More

              "StadtLandHund": Erlebnistouren mit dem Vierbeiner - Wiesbadener Kurier

              deutschland
              businessidee

               Posted on Nov 18

<dummy>      Bewegende Erlebnistouren für Mensch und Hund". So nennt Dagmar Weyerhäuser ihre Idee, für die sie 2012 bereits einen "Innovationspreis" entgegennehmen durfte: Ihr Ziel mit "StadtLandHund" ist es, Menschen mit und ohne Hund die schöne...</dummy>

Read More

            Next page

              Recent Articles

                Nun ist es raus: Hunde sind klüger als Katzen Dec  5

                Die Macht der Gerüche Jul 27

                Vorsicht giftig! Diese Lebensmittel sollten Hunde nicht fressen Jun 21

                Studie: Schäferhunde können Brustkrebs diagnostizieren Mar 27

                Atopische Dermatitis: Was tun, wenn es juckt und kratzt? / Allergien belasten das Wohlbefinden ... Mar 27

                Tiermedizin - Epilepsie-Gen entdeckt Feb 27

                Auch Haustiere frieren | So kommt Bello durch den Winter Jan 17

                Hunde sind bei Minusgraden schnell unterkühlt Jan 17

                Venedig: Wo die Gondeln Hunde tragen Dec  8

                Hunde heulten halbe Stunde vor Erdbeben Nov  1

              ©2018 dognews - Disclaimer
Powered by Cloudburo Curation Engine

              Categories

                businessidee (38)

                deutschland (596)

                erziehung (35)

                fotografie (5)

                freizeit (83)

                gesetz (38)

                gesundheit (116)

                herdenhunde (10)

                hundesachkunde (13)

                hundesport (12)

                kinder (9)

                kurioses (29)

                oesterreich (63)

                rassen (8)

                ratgeber (161)

                rettungshunde (3)

                schweiz (99)

                senioren (10)

                stars (11)

                urlaub (39)

                veranstaltung (1)

                wandern (17)

                wissen (200)

              By year

                2017 (8)

                2016 (55)

                2015 (458)

                2014 (273)