org.scalatest.words.ShouldVerb.scala Maven / Gradle / Ivy
Show all versions of scalatest_2.11.0-RC2 Show documentation
/*
* Copyright 2001-2013 Artima, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.scalatest.words
import org.scalatest._
/**
* Provides an implicit conversion that adds should methods to String
* to support the syntax of FlatSpec, WordSpec, fixture.FlatSpec,
* and fixture.WordSpec.
*
*
* For example, this trait enables syntax such as the following test registration in FlatSpec
* and fixture.FlatSpec:
*
*
*
* "A Stack (when empty)" should "be empty" in { ... }
* ^
*
*
*
* It also enables syntax such as the following shared test registration in FlatSpec
* and fixture.FlatSpec:
*
*
*
* "A Stack (with one item)" should behave like nonEmptyStack(stackWithOneItem, lastValuePushed)
* ^
*
*
*
* In addition, it supports the registration of subject descriptions in WordSpec
* and fixture.WordSpec, such as:
*
*
*
* "A Stack (when empty)" should { ...
* ^
*
*
*
* And finally, it also supportds the registration of subject descriptions with after words
* in WordSpec and fixture.WordSpec. For example:
*
*
*
* def provide = afterWord("provide")
*
* "The ScalaTest Matchers DSL" should provide {
* ^
*
*
*
* The reason this implicit conversion is provided in a separate trait, instead of being provided
* directly in FlatSpec, WordSpec, fixture.FlatSpec, and
* fixture.WordSpec, is because an implicit conversion provided directly would conflict
* with the implicit conversion that provides should methods on String
* in the ShouldMatchers trait. By contrast, there is no conflict with
* the separate ShouldVerb trait approach, because:
*
*
*
* FlatSpec, WordSpec, fixture.FlatSpec, and fixture.WordSpec
* mix in ShouldVerb directly, andShouldMatchers extends ShouldVerb, overriding the
* convertToStringShouldWrapper implicit conversion function.
*
*
* So whether or not
* a FlatSpec, WordSpec, fixture.FlatSpec, or fixture.WordSpec
* mixes in ShouldMatchers, there will only be one
* implicit conversion in scope that adds should methods to Strings.
*
*
*
* Also, because the class of the result of the overriding convertToStringShouldWrapper
* implicit conversion method provided in ShouldMatchers extends this trait's
* StringShouldWrapperForVerb class, the four uses of should provided here
* are still available. These four should are in fact available to any class
* that mixes in ShouldMatchers, but each takes an implicit parameter that is provided
* only in FlatSpec and fixture.FlatSpec, or WordSpec and
* fixture.WordSpec.
*
*
* @author Bill Venners
*/
trait ShouldVerb {
// This can't be final or abstract, because it is instantiated directly by the implicit conversion, and
// extended by something in ShouldMatchers.
/**
* This class supports the syntax of FlatSpec, WordSpec, fixture.FlatSpec,
* and fixture.WordSpec.
*
*
* This class is used in conjunction with an implicit conversion to enable should methods to
* be invoked on Strings.
*
*
* @author Bill Venners
*/
trait StringShouldWrapperForVerb {
// Don't use "left" because that conflicts with Scalaz's left method on strings
val leftSideString: String
/**
* Supports test registration in FlatSpec and fixture.FlatSpec.
*
*
* For example, this method enables syntax such as the following in FlatSpec
* and fixture.FlatSpec:
*
*
*
* "A Stack (when empty)" should "be empty" in { ... }
* ^
*
*
*
* FlatSpec passes in a function via the implicit parameter that takes
* three strings and results in a ResultOfStringPassedToVerb. This method
* simply invokes this function, passing in leftSideString, the verb string
* "should", and right, and returns the result.
*
*/
def should(right: String)(implicit fun: (String, String, String) => ResultOfStringPassedToVerb): ResultOfStringPassedToVerb = {
fun(leftSideString, "should", right)
}
/**
* Supports shared test registration in FlatSpec and fixture.FlatSpec.
*
*
* For example, this method enables syntax such as the following in FlatSpec
* and fixture.FlatSpec:
*
*
*
* "A Stack (with one item)" should behave like nonEmptyStack(stackWithOneItem, lastValuePushed)
* ^
*
*
*
* FlatSpec and fixture.FlatSpec passes in a function via the implicit parameter that takes
* a string and results in a BehaveWord. This method
* simply invokes this function, passing in leftSideString, and returns the result.
*
*/
def should(right: BehaveWord)(implicit fun: (String) => BehaveWord): BehaveWord = {
fun(leftSideString)
}
/**
* Supports the registration of subject descriptions in WordSpec
* and fixture.WordSpec.
*
*
* For example, this method enables syntax such as the following in WordSpec
* and fixture.WordSpec:
*
*
*
* "A Stack (when empty)" should { ...
* ^
*
*
*
* WordSpec passes in a function via the implicit parameter of type StringVerbBlockRegistration,
* a function that takes two strings and a no-arg function and results in Unit. This method
* simply invokes this function, passing in leftSideString, the verb string
* "should", and the right by-name parameter transformed into a
* no-arg function.
*
*/
def should(right: => Unit)(implicit fun: StringVerbBlockRegistration) {
fun(leftSideString, "should", right _)
}
/**
* Supports the registration of subject descriptions with after words
* in WordSpec and fixture.WordSpec.
*
*
* For example, this method enables syntax such as the following in WordSpec
* and fixture.WordSpec:
*
*
*
* def provide = afterWord("provide")
*
* "The ScalaTest Matchers DSL" should provide {
* ^
*
*
*
* WordSpec passes in a function via the implicit parameter that takes
* two strings and a ResultOfAfterWordApplication and results in Unit. This method
* simply invokes this function, passing in leftSideString, the verb string
* "should", and the ResultOfAfterWordApplication passed to should.
*
*/
def should(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit fun: (String, String, ResultOfAfterWordApplication) => Unit) {
fun(leftSideString, "should", resultOfAfterWordApplication)
}
}
import scala.language.implicitConversions
/**
* Implicitly converts an object of type String to a StringShouldWrapperForVerb,
* to enable should methods to be invokable on that object.
*/
implicit def convertToStringShouldWrapper(o: String): StringShouldWrapperForVerb =
new StringShouldWrapperForVerb {
val leftSideString = o.trim
}
}