org.scalatest.matchers.Matcher.scala Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalatest_2.11.0-M5 Show documentation
Show all versions of scalatest_2.11.0-M5 Show documentation
ScalaTest is a free, open-source testing toolkit for Scala and Java
programmers.
The newest version!
/*
* 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.matchers
import org.scalatest.enablers._
import org.scalatest.MatchersHelper.orMatchersAndApply
import org.scalatest.MatchersHelper.andMatchersAndApply
import org.scalatest.words.MatcherWords
import scala.collection.GenTraversable
import scala.util.matching.Regex
import org.scalautils.Equality
import org.scalautils.TripleEqualsSupport.Spread
import org.scalautils.TripleEqualsSupport.TripleEqualsInvocation
import org.scalautils.Prettifier
import org.scalatest.FailureMessages
import org.scalatest.Resources
import org.scalatest.words.FullyMatchWord
import org.scalatest.words.StartWithWord
import org.scalatest.words.EndWithWord
import org.scalatest.words.IncludeWord
import org.scalatest.words.HaveWord
import org.scalatest.words.BeWord
import org.scalatest.words.NotWord
import org.scalatest.words.ContainWord
import org.scalatest.words.ResultOfLengthWordApplication
import org.scalatest.words.ResultOfSizeWordApplication
import org.scalatest.words.ResultOfMessageWordApplication
import org.scalatest.words.ResultOfLessThanComparison
import org.scalatest.words.ResultOfGreaterThanComparison
import org.scalatest.words.ResultOfLessThanOrEqualToComparison
import org.scalatest.words.ResultOfGreaterThanOrEqualToComparison
import org.scalatest.words.ResultOfAWordToSymbolApplication
import org.scalatest.words.ResultOfAWordToBePropertyMatcherApplication
import org.scalatest.words.ResultOfAWordToAMatcherApplication
import org.scalatest.words.ResultOfAnWordToSymbolApplication
import org.scalatest.words.ResultOfAnWordToBePropertyMatcherApplication
import org.scalatest.words.ResultOfAnWordToAnMatcherApplication
import org.scalatest.words.ResultOfTheSameInstanceAsApplication
import org.scalatest.words.ResultOfRegexWordApplication
import org.scalatest.words.RegexWithGroups
import org.scalatest.words.ResultOfDefinedAt
import org.scalatest.words.ResultOfOneOfApplication
import org.scalatest.words.ResultOfAtLeastOneOfApplication
import org.scalatest.words.ResultOfNoneOfApplication
import org.scalatest.words.ResultOfTheSameElementsAsApplication
import org.scalatest.words.ResultOfTheSameElementsInOrderAsApplication
import org.scalatest.words.ResultOfOnlyApplication
import org.scalatest.words.ResultOfAllOfApplication
import org.scalatest.words.ResultOfInOrderOnlyApplication
import org.scalatest.words.ResultOfInOrderApplication
import org.scalatest.words.ResultOfKeyWordApplication
import org.scalatest.words.ResultOfValueWordApplication
import org.scalatest.words.ResultOfAtMostOneOfApplication
import org.scalatest.words.SortedWord
import org.scalatest.words.ResultOfATypeInvocation
import org.scalatest.words.ResultOfAnTypeInvocation
import org.scalatest.words.ExistWord
import org.scalatest.words.ResultOfNotExist
import org.scalatest.words.ReadableWord
import org.scalatest.words.WritableWord
import org.scalatest.words.EmptyWord
import org.scalatest.words.DefinedWord
/**
* Trait extended by objects that can match a value of the specified type. The value to match is
* passed to the matcher's apply method. The result is a MatchResult.
* A matcher is, therefore, a function from the specified type, T, to a MatchResult.
*
*
* Creating custom matchers
*
*
* Note: We are planning on adding some new matchers to ScalaTest in a future release, and would like your feedback.
* Please let us know if you have felt the need for a matcher ScalaTest doesn't yet provide, whether or
* not you wrote a custom matcher for it. Please email your feedback to bill AT artima.com.
*
*
*
* If none of the built-in matcher syntax satisfies a particular need you have, you can create
* custom Matchers that allow
* you to place your own syntax directly after should or must. For example, class java.io.File has a method exists, which
* indicates whether a file of a certain path and name exists. Because the exists method takes no parameters and returns Boolean,
* you can call it using be with a symbol or BePropertyMatcher, yielding assertions like:
*
*
*
* file should be ('exists) // using a symbol
* file should be (inExistance) // using a BePropertyMatcher
*
*
*
* Although these expressions will achieve your goal of throwing a TestFailedException if the file does not exist, they don't produce
* the most readable code because the English is either incorrect or awkward. In this case, you might want to create a
* custom Matcher[java.io.File]
* named exist, which you could then use to write expressions like:
*
*
*
* // using a plain-old Matcher
* file should exist
* file should not (exist)
* file should (exist and have ('name ("temp.txt")))
*
*
*
* One good way to organize custom matchers is to place them inside one or more
* traits that you can then mix into the suites or specs that need them. Here's an example:
*
*
*
* trait CustomMatchers {
*
* class FileExistsMatcher extends Matcher[java.io.File] {
*
* def apply(left: java.io.File) = {
*
* val fileOrDir = if (left.isFile) "file" else "directory"
*
* val failureMessageSuffix =
* fileOrDir + " named " + left.getName + " did not exist"
*
* val negatedFailureMessageSuffix =
* fileOrDir + " named " + left.getName + " existed"
*
* MatchResult(
* left.exists,
* "The " + failureMessageSuffix,
* "The " + negatedFailureMessageSuffix,
* "the " + failureMessageSuffix,
* "the " + negatedFailureMessageSuffix
* )
* }
* }
*
* val exist = new FileExistsMatcher
* }
*
* // Make them easy to import with:
* // import CustomMatchers._
* object CustomMatchers extends CustomMatchers
*
*
*
* Note: the CustomMatchers companion object exists to make it easy to bring the
* matchers defined in this trait into scope via importing, instead of mixing in the trait. The ability
* to import them is useful, for example, when you want to use the matchers defined in a trait in the Scala interpreter console.
*
*
*
* This trait contains one matcher class, FileExistsMatcher, and a val named exist that refers to
* an instance of FileExistsMatcher. Because the class extends Matcher[java.io.File],
* the compiler will only allow it be used to match against instances of java.io.File. A matcher must declare an
* apply method that takes the type decared in Matcher's type parameter, in this case java.io.File.
* The apply method will return a MatchResult whose matches field will indicate whether the match succeeded.
* The failureMessage field will provide a programmer-friendly error message indicating, in the event of a match failure, what caused
* the match to fail.
*
*
*
* The FileExistsMatcher matcher in this example determines success by calling exists on the passed java.io.File. It
* does this in the first argument passed to the MatchResult factory method:
*
*
*
* left.exists,
*
*
*
* In other words, if the file exists, this matcher matches.
* The next argument to MatchResult's factory method produces the failure message string:
*
*
*
* "The " + failureMessageSuffix,
*
*
*
* If the passed java.io.File is a file (not a directory) and has the name temp.txt, for example, the failure
* message would be:
*
*
*
* The file named temp.txt did not exist
*
*
*
* For more information on the fields in a MatchResult, including the subsequent three fields that follow the failure message,
* please see the documentation for MatchResult.
*
*
*
* Given the CustomMatchers trait as defined above, you can use the exist syntax in any suite or spec in
* which you mix in the trait:
*
*
*
* class ExampleSpec extends Spec with ShouldMatchers with CustomMatchers {
*
* describe("A temp file") {
*
* it("should be created and deleted") {
*
* val tempFile = java.io.File.createTempFile("delete", "me")
*
* try {
* // At this point the temp file should exist
* tempFile should exist
* }
* finally {
* tempFile.delete()
* }
*
* // At this point it should not exist
* tempFile should not (exist)
* }
* }
* }
*
*
*
* Note that when you use custom Matchers, you will need to put parentheses around the custom matcher when if follows not,
* as shown in the last assertion above: tempFile should not (exist).
*
*
* Other ways to create matchers
*
*
* There are other ways to create new matchers besides defining one as shown above. For example, you would normally check to ensure
* an option is defined like this:
*
*
*
* Some("hi") should be ('defined)
*
*
*
* If you wanted to get rid of the tick mark, you could simply define defined like this:
*
*
*
* val defined = 'defined
*
*
*
* Now you can check that an option is defined without the tick mark:
*
*
*
* Some("hi") should be (defined)
*
*
*
* Perhaps after using that for a while, you realize you're tired of typing the parentheses. You could
* get rid of them with another one-liner:
*
*
*
* val beDefined = be (defined)
*
*
*
* Now you can check that an option is defined without the tick mark or the parentheses:
*
*
*
* Some("hi") should beDefined
*
*
*
* You can also use ScalaTest matchers' logical operators to combine existing matchers into new ones, like this:
*
*
*
* val beWithinTolerance = be >= 0 and be <= 10
*
*
*
* Now you could check that a number is within the tolerance (in this case, between 0 and 10, inclusive), like this:
*
*
*
* num should beWithinTolerance
*
*
*
* When defining a full blown matcher, one shorthand is to use one of the factory methods in Matcher's companion
* object. For example, instead of writing this:
*
*
*
* val beOdd =
* new Matcher[Int] {
* def apply(left: Int) =
* MatchResult(
* left % 2 == 1,
* left + " was not odd",
* left + " was odd"
* )
* }
*
*
*
* You could alternately write this:
*
*
*
* val beOdd =
* Matcher { (left: Int) =>
* MatchResult(
* left % 2 == 1,
* left + " was not odd",
* left + " was odd"
* )
* }
*
*
*
* Either way you define the beOdd matcher, you could use it like this:
*
*
*
* 3 should beOdd
* 4 should not (beOdd)
*
*
*
* You can also compose matchers. If for some odd reason, you wanted a Matcher[String] that
* checked whether a string, when converted to an Int,
* was odd, you could make one by composing beOdd with
* a function that converts a string to an Int, like this:
*
*
*
* val beOddAsInt = beOdd compose { (s: String) => s.toInt }
*
*
*
* Now you have a Matcher[String] whose apply method first
* invokes the converter function to convert the passed string to an Int,
* then passes the resulting Int to beOdd. Thus, you could use
* beOddAsInt like this:
*
*
*
* "3" should beOddAsInt
* "4" should not (beOddAsInt)
*
*
*
* You can also define a method that produces a matcher using matcher
* composition and a passed parameter. For example, here's how you could create a Matcher[File] from a
* Matcher[String]:
*
*
*
* import java.io.File
*
* def endWithExtension(ext: String) = endWith(ext) compose { (f: File) => f.getPath }
*
*
*
* Every time you call the above endWithExtension method, you'll get a new Matcher[File]. Here's an example:
*
*
*
* new File("output.txt") should endWithExtension("txt")
*
*
* Matcher's variance
*
*
* Matcher is contravariant in its type parameter, T, to make its use more flexible.
* As an example, consider the hierarchy:
*
*
*
* class Fruit
* class Orange extends Fruit
* class ValenciaOrange extends Orange
*
*
*
* Given an orange:
*
*
*
* val orange = Orange
*
*
*
* The expression "orange should" will, via an implicit conversion in ShouldMatchers,
* result in an object that has a should
* method that takes a Matcher[Orange]. If the static type of the matcher being passed to should is
* Matcher[Valencia] it shouldn't (and won't) compile. The reason it shouldn't compile is that
* the left value is an Orange, but not necessarily a Valencia, and a
* Matcher[Valencia] only knows how to match against a Valencia. The reason
* it won't compile is given that Matcher is contravariant in its type parameter, T, a
* Matcher[Valencia] is not a subtype of Matcher[Orange].
*
*
*
* By contrast, if the static type of the matcher being passed to should is Matcher[Fruit],
* it should (and will) compile. The reason it should compile is that given the left value is an Orange,
* it is also a Fruit, and a Matcher[Fruit] knows how to match against Fruits.
* The reason it will compile is that given that Matcher is contravariant in its type parameter, T, a
* Matcher[Fruit] is indeed a subtype of Matcher[Orange].
*
*
* @author Bill Venners
*/
trait Matcher[-T] extends Function1[T, MatchResult] { outerInstance =>
/**
* Check to see if the specified object, left, matches, and report the result in
* the returned MatchResult. The parameter is named left, because it is
* usually the value to the left of a should or must invocation. For example,
* in:
*
*
* list should equal (List(1, 2, 3))
*
*
* The equal (List(1, 2, 3)) expression results in a matcher that holds a reference to the
* right value, List(1, 2, 3). The should method invokes apply
* on this matcher, passing in list, which is therefore the "left" value. The
* matcher will compare the list (the left value) with List(1, 2, 3) (the right
* value), and report the result in the returned MatchResult.
*
* @param left the value against which to match
* @return the MatchResult that represents the result of the match
*/
def apply(left: T): MatchResult
/**
* Compose this matcher with the passed function, returning a new matcher.
*
*
* This method overrides compose on Function1 to
* return a more specific function type of Matcher. For example, given
* a beOdd matcher defined like this:
*
*
*
* val beOdd =
* new Matcher[Int] {
* def apply(left: Int) =
* MatchResult(
* left % 2 == 1,
* left + " was not odd",
* left + " was odd"
* )
* }
*
*
*
* You could use beOdd like this:
*
*
*
* 3 should beOdd
* 4 should not (beOdd)
*
*
*
* If for some odd reason, you wanted a Matcher[String] that
* checked whether a string, when converted to an Int,
* was odd, you could make one by composing beOdd with
* a function that converts a string to an Int, like this:
*
*
*
* val beOddAsInt = beOdd compose { (s: String) => s.toInt }
*
*
*
* Now you have a Matcher[String] whose apply method first
* invokes the converter function to convert the passed string to an Int,
* then passes the resulting Int to beOdd. Thus, you could use
* beOddAsInt like this:
*
*
*
* "3" should beOddAsInt
* "4" should not (beOddAsInt)
*
*/
override def compose[U](g: U => T): Matcher[U] =
new Matcher[U] {
def apply(u: U) = outerInstance.apply(g(u))
}
// TODO: mention not short circuited, and the precendence is even between and and or
/**
* Returns a matcher whose apply method returns a MatchResult
* that represents the logical-and of the results of the wrapped and the passed matcher applied to
* the same value.
*
*
* The reason and has an upper bound on its type parameter is so that the Matcher
* resulting from an invocation of and will have the correct type parameter. If you call
* and on a Matcher[Orange], passing in a Matcher[Valencia],
* the result will have type Matcher[Valencia]. This is correct because both a
* Matcher[Orange] and a Matcher[Valencia] know how to match a
* Valencia (but a Matcher[Valencia] doesn't know how to
* match any old Orange). If you call
* and on a Matcher[Orange], passing in a Matcher[Fruit],
* the result will have type Matcher[Orange]. This is also correct because both a
* Matcher[Orange] and a Matcher[Fruit] know how to match an
* Orange (but a Matcher[Orange] doesn't know how to
* match any old Fruit).
*
*
* @param the matcher to logical-and with this matcher
* @return a matcher that performs the logical-and of this and the passed matcher
*/
def and[U <: T](rightMatcher: Matcher[U]): Matcher[U] =
new Matcher[U] {
def apply(left: U): MatchResult = {
andMatchersAndApply(left, outerInstance, rightMatcher)
}
override def toString: String = "(" + Prettifier.default(outerInstance) + ") and (" + Prettifier.default(rightMatcher) + ")"
}
/**
* Returns a MatcherFactory whose matcher method returns a Matcher,
* which has apply method that returns a MatchResult that represents the logical-and
* of the results of the wrapped and the passed MatcherFactory applied to the same value.
*
* @param rightMatcherFactory1 the MatcherFactory to logical-and with this MatcherFactory
* @return a MatcherFactory that performs the logical-and of this and the passed MatcherFactory
*/
def and[U, TC1[_]](rightMatcherFactory1: MatcherFactory1[U, TC1]): MatcherFactory1[T with U, TC1] =
new MatcherFactory1[T with U, TC1] {
def matcher[V <: T with U : TC1]: Matcher[V] = {
new Matcher[V] {
def apply(left: V): MatchResult = {
val rightMatcher = rightMatcherFactory1.matcher
andMatchersAndApply(left, outerInstance, rightMatcher)
}
}
}
override def toString: String = "(" + Prettifier.default(outerInstance) + ") and (" + Prettifier.default(rightMatcherFactory1) + ")"
}
/**
* Returns a matcher whose apply method returns a MatchResult
* that represents the logical-or of the results of this and the passed matcher applied to
* the same value.
*
*
* The reason or has an upper bound on its type parameter is so that the Matcher
* resulting from an invocation of or will have the correct type parameter. If you call
* or on a Matcher[Orange], passing in a Matcher[Valencia],
* the result will have type Matcher[Valencia]. This is correct because both a
* Matcher[Orange] and a Matcher[Valencia] know how to match a
* Valencia (but a Matcher[Valencia] doesn't know how to
* match any old Orange). If you call
* or on a Matcher[Orange], passing in a Matcher[Fruit],
* the result will have type Matcher[Orange]. This is also correct because both a
* Matcher[Orange] and a Matcher[Fruit] know how to match an
* Orange (but a Matcher[Orange] doesn't know how to
* match any old Fruit).
*
*
* @param rightMatcher the matcher to logical-or with this matcher
* @return a matcher that performs the logical-or of this and the passed matcher
*/
def or[U <: T](rightMatcher: Matcher[U]): Matcher[U] =
new Matcher[U] {
def apply(left: U): MatchResult = {
orMatchersAndApply(left, outerInstance, rightMatcher)
}
override def toString: String = "(" + Prettifier.default(outerInstance) + ") or (" + Prettifier.default(rightMatcher) + ")"
}
/**
* Returns a MatcherFactory whose matcher method returns a Matcher,
* which has apply method that returns a MatchResult that represents the logical-or
* of the results of the wrapped and the passed MatcherFactory applied to the same value.
*
* @param rightMatcherFactory1 the MatcherFactory to logical-or with this MatcherFactory
* @return a MatcherFactory that performs the logical-or of this and the passed MatcherFactory
*/
def or[U, TC1[_]](rightMatcherFactory1: MatcherFactory1[U, TC1]): MatcherFactory1[T with U, TC1] =
new MatcherFactory1[T with U, TC1] {
def matcher[V <: T with U : TC1]: Matcher[V] = {
new Matcher[V] {
def apply(left: V): MatchResult = {
val rightMatcher = rightMatcherFactory1.matcher
orMatchersAndApply(left, outerInstance, rightMatcher)
}
override def toString: String = "(" + Prettifier.default(outerInstance) + ") or (" + Prettifier.default(rightMatcherFactory1) + ")"
}
}
override def toString: String = "(" + Prettifier.default(outerInstance) + ") or (" + Prettifier.default(rightMatcherFactory1) + ")"
}
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndHaveWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and have length (3 - 1)
* ^
*
*/
def length(expectedLength: Long): MatcherFactory1[T, Length] = and(MatcherWords.have.length(expectedLength))
/**
* This method enables the following syntax:
*
*
* aMatcher and have size (3 - 1)
* ^
*
*/
def size(expectedSize: Long): MatcherFactory1[T, Size] = and(MatcherWords.have.size(expectedSize))
/**
* This method enables the following syntax:
*
*
* aMatcher and have message ("A message from Mars")
* ^
*
*/
def message(expectedMessage: String): MatcherFactory1[T, Messaging] = and(MatcherWords.have.message(expectedMessage))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and have size (3 - 1)
* ^
*
*/
def and(haveWord: HaveWord): AndHaveWord = new AndHaveWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndContainWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and contain (3 - 1)
* ^
*
*/
def apply[U](expectedElement: Any): MatcherFactory1[T with U, Containing] = outerInstance.and(MatcherWords.contain(expectedElement))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain key ("one")
* ^
*
*/
def key(expectedKey: Any): MatcherFactory1[T, KeyMapping] = outerInstance.and(MatcherWords.contain.key(expectedKey))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain value (1)
* ^
*
*/
def value(expectedValue: Any): MatcherFactory1[T, ValueMapping] = outerInstance.and(MatcherWords.contain.value(expectedValue))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain theSameElementsAs List(1, 2, 3)
* ^
*
*/
def theSameElementsAs(right: GenTraversable[_]): MatcherFactory1[T, Aggregating] =
outerInstance.and(MatcherWords.contain.theSameElementsAs(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain theSameElementsInOrderAs List(1, 2, 3)
* ^
*
*/
def theSameElementsInOrderAs(right: GenTraversable[_]): MatcherFactory1[T, Sequencing] =
outerInstance.and(MatcherWords.contain.theSameElementsInOrderAs(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain inOrderOnly (1, 2, 3)
* ^
*
*/
def inOrderOnly(right: Any*): MatcherFactory1[T, Sequencing] =
outerInstance.and(MatcherWords.contain.inOrderOnly(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain allOf (1, 2, 3)
* ^
*
*/
def allOf(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.and(MatcherWords.contain.allOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain inOrder (1, 2, 3)
* ^
*
*/
def inOrder(right: Any*): MatcherFactory1[T, Sequencing] =
outerInstance.and(MatcherWords.contain.inOrder(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain oneOf (1, 2, 3)
* ^
*
*/
def oneOf(right: Any*): MatcherFactory1[T, Containing] =
outerInstance.and(MatcherWords.contain.oneOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain atLeastOneOf (1, 2, 3)
* ^
*
*/
def atLeastOneOf(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.and(MatcherWords.contain.atLeastOneOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain only (1, 2, 3)
* ^
*
*/
def only(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.and(MatcherWords.contain.only(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain noneOf (1, 2, 3)
* ^
*
*/
def noneOf(right: Any*): MatcherFactory1[T, Containing] =
outerInstance.and(MatcherWords.contain.noneOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher and contain atMostOneOf (1, 2, 3)
* ^
*
*/
def atMostOneOf(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.and(MatcherWords.contain.atMostOneOf(right.toList: _*))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and contain key ("one")
* ^
*
*/
def and(containWord: ContainWord): AndContainWord = new AndContainWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndBeWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and be a ('file)
* ^
*
*/
def a(symbol: Symbol): Matcher[T with AnyRef] = and(MatcherWords.be.a(symbol))
/**
* This method enables the following syntax, where file is a BePropertyMatcher:
*
*
* aMatcher and be a (file)
* ^
*
*/
def a[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U] = and(MatcherWords.be.a(bePropertyMatcher))
/**
* This method enables the following syntax, where positiveNumber and validNumber are AMatcher:
*
*
* aMatcher and be a (validNumber)
* ^
*
*/
def a[U](aMatcher: AMatcher[U]): Matcher[T with U] = and(MatcherWords.be.a(aMatcher))
/**
* This method enables the following syntax:
*
*
* aMatcher and be an ('apple)
* ^
*
*/
def an(symbol: Symbol): Matcher[T with AnyRef] = and(MatcherWords.be.an(symbol))
/**
* This method enables the following syntax, where apple is a BePropertyMatcher:
*
*
* aMatcher and be an (apple)
* ^
*
*/
def an[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U] = and(MatcherWords.be.an(bePropertyMatcher))
/**
* This method enables the following syntax, where integerNumber is an AnMatcher:
*
*
* aMatcher and be an (integerNumber)
* ^
*
*/
def an[U](anMatcher: AnMatcher[U]): Matcher[T with U] = and(MatcherWords.be.an(anMatcher))
/**
* This method enables the following syntax:
*
*
* aMatcher and be theSameInstanceAs (string)
* ^
*
*/
def theSameInstanceAs(anyRef: AnyRef): Matcher[T with AnyRef] = and(MatcherWords.be.theSameInstanceAs(anyRef))
/**
* This method enables the following syntax, where fraction refers to a PartialFunction:
*
*
* aMatcher and be definedAt (8)
* ^
*
*/
def definedAt[A, U <: PartialFunction[A, _]](right: A): Matcher[T with U] = and(MatcherWords.be.definedAt(right))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and be a ('file)
* ^
*
*/
def and(beWord: BeWord): AndBeWord = new AndBeWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndFullyMatchWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and fullyMatch regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = and(MatcherWords.fullyMatch.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher and fullyMatch regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = and(MatcherWords.fullyMatch.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher and fullyMatch regex (decimalRegex)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = and(MatcherWords.fullyMatch.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and fullyMatch regex (decimalRegex)
* ^
*
*/
def and(fullyMatchWord: FullyMatchWord): AndFullyMatchWord = new AndFullyMatchWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndIncludeWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and include regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = and(MatcherWords.include.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher and include regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = and(MatcherWords.include.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher and include regex (decimalRegex)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = and(MatcherWords.include.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and include regex ("wor.d")
* ^
*
*/
def and(includeWord: IncludeWord): AndIncludeWord = new AndIncludeWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndStartWithWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and startWith regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = and(MatcherWords.startWith.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher and startWith regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = and(MatcherWords.startWith.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher and startWith regex (decimalRegex)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = and(MatcherWords.startWith.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and startWith regex ("1.7")
* ^
*
*/
def and(startWithWord: StartWithWord): AndStartWithWord = new AndStartWithWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndEndWithWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and endWith regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = and(MatcherWords.endWith.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher and endWith regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = and(MatcherWords.endWith.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher and endWith regex (decimalRegex)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = and(MatcherWords.endWith.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and endWith regex (decimalRegex)
* ^
*
*/
def and(endWithWord: EndWithWord): AndEndWithWord = new AndEndWithWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class AndNotWord {
/**
* This method enables the following syntax:
*
*
* aMatcher and not equal (3 - 1)
* ^
*
*/
def equal(any: Any): MatcherFactory1[T, Equality] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.equal(any)))
/**
* This method enables the following syntax, for the "primitive" numeric types:
*
*
* aMatcher and not equal (17.0 +- 0.2)
* ^
*
*/
def equal[U](spread: Spread[U]): Matcher[T with U] = outerInstance.and(MatcherWords.not.equal(spread))
/**
* This method enables the following syntax:
*
*
* aMatcher and not equal (null)
* ^
*
*/
def equal(o: Null): Matcher[T] = {
outerInstance and {
new Matcher[T] {
def apply(left: T): MatchResult = {
MatchResult(
left != null,
Resources("equaledNull"),
Resources("didNotEqualNull"),
Resources("midSentenceEqualedNull"),
Resources("didNotEqualNull"),
Vector.empty,
Vector(left)
)
}
override def toString: String = "not equal null"
}
}
}
/**
* This method enables the following syntax:
*
*
* aMatcher and not be (3 - 1)
* ^
*
*/
def be(any: Any): Matcher[T] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.be(any)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not have length (3)
* ^
*
*/
def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[T, Length] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.have.length(resultOfLengthWordApplication.expectedLength)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not have size (3)
* ^
*
*/
def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[T, Size] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.have.size(resultOfSizeWordApplication.expectedSize)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not have message ("Message from Mars!")
* ^
*
*/
def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[T, Messaging] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.have.message(resultOfMessageWordApplication.expectedMessage)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not have (author ("Melville"))
* ^
*
*/
def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): Matcher[T with U] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.have(firstPropertyMatcher, propertyMatchers: _*)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be < (6)
* ^
*
*/
def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): Matcher[T with U] =
outerInstance.and(MatcherWords.not.be(resultOfLessThanComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be (null)
* ^
*
*/
def be(o: Null): Matcher[T with AnyRef] = outerInstance.and(MatcherWords.not.be(o))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be > (6)
* ^
*
*/
def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): Matcher[T with U] =
outerInstance.and(MatcherWords.not.be(resultOfGreaterThanComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be <= (2)
* ^
*
*/
def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): Matcher[T with U] =
outerInstance.and(MatcherWords.not.be(resultOfLessThanOrEqualToComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be >= (6)
* ^
*
*/
def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): Matcher[T with U] =
outerInstance.and(MatcherWords.not.be(resultOfGreaterThanOrEqualToComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be === (6)
* ^
*
*/
def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T] =
outerInstance.and(MatcherWords.not.be(tripleEqualsInvocation))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be ('empty)
* ^
*
*/
def be(symbol: Symbol): Matcher[T with AnyRef] = outerInstance.and(MatcherWords.not.be(symbol))
/**
* This method enables the following syntax, where odd is a BeMatcher:
*
*
* aMatcher and not be (odd)
* ^
*
*/
def be[U](beMatcher: BeMatcher[U]): Matcher[T with U] = outerInstance.and(MatcherWords.not.be(beMatcher))
/**
* This method enables the following syntax, where directory is a BePropertyMatcher:
*
*
* aMatcher and not be (directory)
* ^
*
*/
def be[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U] = outerInstance.and(MatcherWords.not.be(bePropertyMatcher))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be a ('file)
* ^
*
*/
def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T with AnyRef] = outerInstance.and(MatcherWords.not.be(resultOfAWordApplication))
/**
* This method enables the following syntax, where validMarks is an AMatcher:
*
*
* aMatcher and not be a (validMarks)
* ^
*
*/
def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with U] = outerInstance.and(MatcherWords.not.be(resultOfAWordApplication))
/**
* This method enables the following syntax, where directory is a BePropertyMatcher:
*
*
* aMatcher and not be a (directory)
* ^
*
*/
def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T with U] = outerInstance.and(MatcherWords.not.be(resultOfAWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be an ('apple)
* ^
*
*/
def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T with AnyRef] = outerInstance.and(MatcherWords.not.be(resultOfAnWordApplication))
/**
* This method enables the following syntax, where directory is a BePropertyMatcher:
*
*
* aMatcher and not be an (directory)
* ^
*
*/
def be[T <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[T]) = outerInstance.and(MatcherWords.not.be(resultOfAnWordApplication))
/**
* This method enables the following syntax, where invalidMarks is an AnMatcher:
*
*
* aMatcher and not be an (invalidMarks)
* ^
*
*/
def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with U] = outerInstance.and(MatcherWords.not.be(resultOfAnWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be a [Book]
* ^
*
*/
def be(aType: ResultOfATypeInvocation[_]): Matcher[T] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.be(aType)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be an [Apple]
* ^
*
*/
def be(anType: ResultOfAnTypeInvocation[_]): Matcher[T] =
outerInstance.and(MatcherWords.not.apply(MatcherWords.be(anType)))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be theSameInstanceAs (otherString)
* ^
*
*/
def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T with AnyRef] = outerInstance.and(MatcherWords.not.be(resultOfTheSameInstanceAsApplication))
/**
* This method enables the following syntax, for the "primitive" numeric types:
*
*
* aMatcher and not be (17.0 +- 0.2)
* ^
*
*/
def be[U](spread: Spread[U]): Matcher[T with U] = outerInstance.and(MatcherWords.not.be(spread))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be definedAt (8)
* ^
*
*/
def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[T with U] =
outerInstance.and(MatcherWords.not.be(resultOfDefinedAt))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be sorted
* ^
*
*/
def be(sortedWord: SortedWord) =
outerInstance.and(MatcherWords.not.be(sortedWord))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be readable
* ^
*
*/
def be(readableWord: ReadableWord) =
outerInstance.and(MatcherWords.not.be(readableWord))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be writable
* ^
*
*/
def be(writableWord: WritableWord) =
outerInstance.and(MatcherWords.not.be(writableWord))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be empty
* ^
*
*/
def be(emptyWord: EmptyWord) =
outerInstance.and(MatcherWords.not.be(emptyWord))
/**
* This method enables the following syntax:
*
*
* aMatcher and not be defined
* ^
*
*/
def be(definedWord: DefinedWord) =
outerInstance.and(MatcherWords.not.be(definedWord))
/**
* This method enables the following syntax:
*
*
* aMatcher and not fullyMatch regex (decimal)
* ^
*
*/
def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.and(MatcherWords.not.fullyMatch(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher and not include regex (decimal)
* ^
*
*/
def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.and(MatcherWords.not.include(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher and not include ("1.7")
* ^
*
*/
def include(expectedSubstring: String): Matcher[T with String] =
outerInstance.and(MatcherWords.not.include(expectedSubstring))
/**
* This method enables the following syntax:
*
*
* aMatcher and not startWith regex (decimal)
* ^
*
*/
def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.and(MatcherWords.not.startWith(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher and not startWith ("1.7")
* ^
*
*/
def startWith(expectedSubstring: String): Matcher[T with String] =
outerInstance.and(MatcherWords.not.startWith(expectedSubstring))
/**
* This method enables the following syntax:
*
*
* aMatcher and not endWith regex (decimal)
* ^
*
*/
def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.and(MatcherWords.not.endWith(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher and not endWith ("1.7")
* ^
*
*/
def endWith(expectedSubstring: String): Matcher[T with String] =
outerInstance.and(MatcherWords.not.endWith(expectedSubstring))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain (3)
* ^
*
*/
def contain[U](expectedElement: U): MatcherFactory1[T, Containing] =
outerInstance.and(MatcherWords.not.contain(expectedElement))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain oneOf (List(8, 1, 2))
* ^
*
*/
def contain(right: ResultOfOneOfApplication): MatcherFactory1[T with Any, Containing] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain atLeastOneOf (List(8, 1, 2))
* ^
*
*/
def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory1[T with Any, Aggregating] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain noneOf (List(8, 1, 2))
* ^
*
*/
def contain(right: ResultOfNoneOfApplication): MatcherFactory1[T with Any, Containing] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain theSameElementsAs (List(8, 1, 2))
* ^
*
*/
def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory1[T with Any, Aggregating] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain theSameElementsInOrderAs (List(8, 1, 2))
* ^
*
*/
def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[T with Any, Sequencing] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain only (List(8, 1, 2))
* ^
*
*/
def contain(right: ResultOfOnlyApplication): MatcherFactory1[T with Any, Aggregating] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain inOrderOnly (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory1[T with Any, Sequencing] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain allOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfAllOfApplication): MatcherFactory1[T with Any, Aggregating] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain inOrder (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfInOrderApplication): MatcherFactory1[T, Sequencing] =
outerInstance.and(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain atMostOneOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory1[T with Any, Aggregating] =
outerInstance.and(MatcherWords.not.contain(right))
// TODO: Write tests and impl for contain ResultOfKey/ValueWordApplication
/**
* This method enables the following syntax given a Matcher:
*
*
* aMatcher and not contain key ("three")
* ^
*
*/
def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping] =
outerInstance.and(MatcherWords.not.contain(resultOfKeyWordApplication))
/**
* This method enables the following syntax given a Matcher:
*
*
* aMatcher and not contain value (3)
* ^
*
*/
def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[T, ValueMapping] =
outerInstance.and(MatcherWords.not.contain(resultOfValueWordApplication))
}
/**
* This method enables the following syntax:
*
*
* aMatcher and not contain value (3)
* ^
*
*/
def and(notWord: NotWord): AndNotWord = new AndNotWord
/**
* This method enables the following syntax:
*
*
* aMatcher and exist
* ^
*
*/
def and(existWord: ExistWord): MatcherFactory1[T, Existence] =
outerInstance.and(MatcherWords.exist.matcherFactory)
/**
* This method enables the following syntax:
*
*
* aMatcher and not (exist)
* ^
*
*/
def and(notExist: ResultOfNotExist): MatcherFactory1[T, Existence] =
outerInstance.and(MatcherWords.not.exist)
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrHaveWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or have length (3 - 1)
* ^
*
*/
def length(expectedLength: Long): MatcherFactory1[T, Length] = or(MatcherWords.have.length(expectedLength))
/**
* This method enables the following syntax:
*
*
* aMatcher or have size (3 - 1)
* ^
*
*/
def size(expectedSize: Long): MatcherFactory1[T, Size] = or(MatcherWords.have.size(expectedSize))
/**
* This method enables the following syntax:
*
*
* aMatcher or have message ("Message from Mars!")
* ^
*
*/
def message(expectedMessage: String): MatcherFactory1[T, Messaging] = or(MatcherWords.have.message(expectedMessage))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or have size (3 - 1)
* ^
*
*/
def or(haveWord: HaveWord): OrHaveWord = new OrHaveWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrContainWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or contain (3 - 1)
* ^
*
*/
def apply[U](expectedElement: Any): MatcherFactory1[T with U, Containing] = outerInstance.or(MatcherWords.contain(expectedElement))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain key ("one")
* ^
*
*/
def key(expectedKey: Any): MatcherFactory1[T, KeyMapping] = outerInstance.or(MatcherWords.contain.key(expectedKey))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain value (1)
* ^
*
*/
def value(expectedValue: Any): MatcherFactory1[T, ValueMapping] = outerInstance.or(MatcherWords.contain.value(expectedValue))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain theSameElementsAs List(1, 2, 3)
* ^
*
*/
def theSameElementsAs(right: GenTraversable[_]): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.contain.theSameElementsAs(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain theSameElementsInOrderAs List(1, 2, 3)
* ^
*
*/
def theSameElementsInOrderAs(right: GenTraversable[_]): MatcherFactory1[T, Sequencing] =
outerInstance.or(MatcherWords.contain.theSameElementsInOrderAs(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain allOf (1, 2, 3)
* ^
*
*/
def allOf(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.contain.allOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain inOrder (1, 2, 3)
* ^
*
*/
def inOrder(right: Any*): MatcherFactory1[T, Sequencing] =
outerInstance.or(MatcherWords.contain.inOrder(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain oneOf (1, 2, 3)
* ^
*
*/
def oneOf(right: Any*): MatcherFactory1[T, Containing] =
outerInstance.or(MatcherWords.contain.oneOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain atLeastOneOf (1, 2, 3)
* ^
*
*/
def atLeastOneOf(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.contain.atLeastOneOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain only (1, 2, 3)
* ^
*
*/
def only(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.contain.only(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain inOrderOnly (1, 2, 3)
* ^
*
*/
def inOrderOnly(right: Any*): MatcherFactory1[T, Sequencing] =
outerInstance.or(MatcherWords.contain.inOrderOnly(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain noneOf (1, 2, 3)
* ^
*
*/
def noneOf(right: Any*): MatcherFactory1[T, Containing] =
outerInstance.or(MatcherWords.contain.noneOf(right.toList: _*))
/**
* This method enables the following syntax:
*
*
* aMatcher or contain atMostOneOf (1, 2, 3)
* ^
*
*/
def atMostOneOf(right: Any*): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.contain.atMostOneOf(right.toList: _*))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or contain value (1)
* ^
*
*/
def or(containWord: ContainWord): OrContainWord = new OrContainWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrBeWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or be a ('directory)
* ^
*
*/
def a(symbol: Symbol): Matcher[T with AnyRef] = or(MatcherWords.be.a(symbol))
/**
* This method enables the following syntax, where directory is a BePropertyMatcher:
*
*
* aMatcher or be a (directory)
* ^
*
*/
def a[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U] = or(MatcherWords.be.a(bePropertyMatcher))
/**
* This method enables the following syntax, where positiveNumber and validNumber are AMatcher:
*
*
* aMatcher or be a (validNumber)
* ^
*
*/
def a[U](aMatcher: AMatcher[U]): Matcher[T with U] = or(MatcherWords.be.a(aMatcher))
/**
* This method enables the following syntax:
*
*
* aMatcher or be an ('apple)
* ^
*
*/
def an(symbol: Symbol): Matcher[T with AnyRef] = or(MatcherWords.be.an(symbol))
/**
* This method enables the following syntax, where orange and apple are BePropertyMatcher:
*
*
* aMatcher or be an (apple)
* ^
*
*/
def an[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U] = or(MatcherWords.be.an(bePropertyMatcher))
/**
* This method enables the following syntax, where oddNumber and integerNumber are AnMatcher:
*
*
* aMatcher or be an (integerNumber)
* ^
*
*/
def an[U](anMatcher: AnMatcher[U]): Matcher[T with U] = or(MatcherWords.be.an(anMatcher))
/**
* This method enables the following syntax:
*
*
* aMatcher or be theSameInstanceAs (otherString)
* ^
*
*/
def theSameInstanceAs(anyRef: AnyRef): Matcher[T with AnyRef] = or(MatcherWords.be.theSameInstanceAs(anyRef))
/**
* This method enables the following syntax, where fraction refers to a PartialFunction:
*
*
* aMatcher or be definedAt (8)
* ^
*
*/
def definedAt[A, U <: PartialFunction[A, _]](right: A): Matcher[T with U] = or(MatcherWords.be.definedAt(right))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or be a ('directory)
* ^
*
*/
def or(beWord: BeWord): OrBeWord = new OrBeWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrFullyMatchWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or fullyMatch regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = or(MatcherWords.fullyMatch.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher or fullyMatch regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = or(MatcherWords.fullyMatch.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher or fullyMatch regex (decimal)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = or(MatcherWords.fullyMatch.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or fullyMatch regex (decimal)
* ^
*
*/
def or(fullyMatchWord: FullyMatchWord): OrFullyMatchWord = new OrFullyMatchWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrIncludeWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or include regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = or(MatcherWords.include.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher or include regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = or(MatcherWords.include.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher or include regex (decimal)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = or(MatcherWords.include.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or include regex ("1.7")
* ^
*
*/
def or(includeWord: IncludeWord): OrIncludeWord = new OrIncludeWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrStartWithWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or startWith regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = or(MatcherWords.startWith.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher or startWith regex ("a(b*)c" withGroup "bb")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = or(MatcherWords.startWith.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher or startWith regex (decimal)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = or(MatcherWords.startWith.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or startWith regex ("1.7")
* ^
*
*/
def or(startWithWord: StartWithWord): OrStartWithWord = new OrStartWithWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrEndWithWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or endWith regex (decimal)
* ^
*
*/
def regex(regexString: String): Matcher[T with String] = or(MatcherWords.endWith.regex(regexString))
/**
* This method enables the following syntax:
*
*
* aMatcher or endWith regex ("d(e*)f" withGroup "ee")
* ^
*
*/
def regex(regexWithGroups: RegexWithGroups): Matcher[T with String] = or(MatcherWords.endWith.regex(regexWithGroups))
/**
* This method enables the following syntax:
*
*
* aMatcher or endWith regex (decimal)
* ^
*
*/
def regex(regex: Regex): Matcher[T with String] = or(MatcherWords.endWith.regex(regex))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or endWith regex ("7b")
* ^
*
*/
def or(endWithWord: EndWithWord): OrEndWithWord = new OrEndWithWord
/**
* This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of
* the matchers DSL.
*
* @author Bill Venners
*/
final class OrNotWord {
/**
* This method enables the following syntax:
*
*
* aMatcher or not equal (2)
* ^
*
*/
def equal(any: Any): MatcherFactory1[T, Equality] =
outerInstance.or(MatcherWords.not.apply(MatcherWords.equal(any)))
/**
* This method enables the following syntax for the "primitive" numeric types:
*
*
* aMatcher or not equal (17.0 +- 0.2)
* ^
*
*/
def equal[U](spread: Spread[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.equal(spread))
/**
* This method enables the following syntax:
*
*
* aMatcher or not equal (null)
* ^
*
*/
def equal(o: Null): Matcher[T] = {
outerInstance or {
new Matcher[T] {
def apply(left: T): MatchResult = {
MatchResult(
left != null,
Resources("equaledNull"),
Resources("didNotEqualNull"),
Resources("midSentenceEqualedNull"),
Resources("didNotEqualNull"),
Vector.empty,
Vector(left)
)
}
override def toString: String = "not equal null"
}
}
}
/**
* This method enables the following syntax:
*
*
* aMatcher or not be (2)
* ^
*
*/
def be(any: Any): Matcher[T] =
outerInstance.or(MatcherWords.not.apply(MatcherWords.be(any)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not have length (3)
* ^
*
*/
def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[T, Length] =
outerInstance.or(MatcherWords.not.apply(MatcherWords.have.length(resultOfLengthWordApplication.expectedLength)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not have size (3)
* ^
*
*/
def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[T, Size] =
outerInstance.or(MatcherWords.not.apply(MatcherWords.have.size(resultOfSizeWordApplication.expectedSize)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not have message ("Message from Mars!")
* ^
*
*/
def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[T, Messaging] =
outerInstance.or(MatcherWords.not.apply(MatcherWords.have.message(resultOfMessageWordApplication.expectedMessage)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not have (author ("Melville"))
* ^
*
*/
def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): Matcher[T with U] =
outerInstance.or(MatcherWords.not.apply(MatcherWords.have(firstPropertyMatcher, propertyMatchers: _*)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be (null)
* ^
*
*/
def be(o: Null): Matcher[T with AnyRef] = outerInstance.or(MatcherWords.not.be(o))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be < (8)
* ^
*
*/
def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): Matcher[T with U] =
outerInstance.or(MatcherWords.not.be(resultOfLessThanComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be > (6)
* ^
*
*/
def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): Matcher[T with U] =
outerInstance.or(MatcherWords.not.be(resultOfGreaterThanComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be <= (2)
* ^
*
*/
def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): Matcher[T with U] =
outerInstance.or(MatcherWords.not.be(resultOfLessThanOrEqualToComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be >= (6)
* ^
*
*/
def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): Matcher[T with U] =
outerInstance.or(MatcherWords.not.be(resultOfGreaterThanOrEqualToComparison))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be === (8)
* ^
*
*/
def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T] =
outerInstance.or(MatcherWords.not.be(tripleEqualsInvocation))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be ('empty)
* ^
*
*/
def be(symbol: Symbol): Matcher[T with AnyRef] = outerInstance.or(MatcherWords.not.be(symbol))
/**
* This method enables the following syntax, where odd is a BeMatcher:
*
*
* aMatcher or not be (odd)
* ^
*
*/
def be[U](beMatcher: BeMatcher[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.be(beMatcher))
/**
* This method enables the following syntax, where file is a BePropertyMatcher:
*
*
* aMatcher or not be (file)
* ^
*
*/
def be[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with AnyRef with U] = outerInstance.or(MatcherWords.not.be(bePropertyMatcher))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be a ('file)
* ^
*
*/
def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T with AnyRef] = outerInstance.or(MatcherWords.not.be(resultOfAWordApplication))
/**
* This method enables the following syntax, where validMarks is an AMatcher:
*
*
* aMatcher or not be a (validMarks)
* ^
*
*/
def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.be(resultOfAWordApplication))
/**
* This method enables the following syntax, where file is a BePropertyMatcher:
*
*
* aMatcher or not be a (file)
* ^
*
*/
def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.be(resultOfAWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be an ('apple)
* ^
*
*/
def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T with AnyRef] = outerInstance.or(MatcherWords.not.be(resultOfAnWordApplication))
/**
* This method enables the following syntax, where apple is a BePropertyMatcher:
*
*
* aMatcher or not be an (apple)
* ^
*
*/
def be[U <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.be(resultOfAnWordApplication))
/**
* This method enables the following syntax, where invalidMarks is an AnMatcher:
*
*
* aMatcher and not be an (invalidMarks)
* ^
*
*/
def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.be(resultOfAnWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be a [Book]
* ^
*
*/
def be(aType: ResultOfATypeInvocation[_]): Matcher[T] = outerInstance.or(MatcherWords.not.apply(MatcherWords.be(aType)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be an [Book]
* ^
*
*/
def be(anType: ResultOfAnTypeInvocation[_]): Matcher[T] = outerInstance.or(MatcherWords.not.apply(MatcherWords.be(anType)))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be theSameInstanceAs (string)
* ^
*
*/
def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T with AnyRef] = outerInstance.or(MatcherWords.not.be(resultOfTheSameInstanceAsApplication))
/**
* This method enables the following syntax for the "primitive" numeric types:
*
*
* aMatcher or not be (17.0 +- 0.2)
* ^
*
*/
def be[U](spread: Spread[U]): Matcher[T with U] = outerInstance.or(MatcherWords.not.be(spread))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be definedAt (8)
* ^
*
*/
def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[T with U] =
outerInstance.or(MatcherWords.not.be(resultOfDefinedAt))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be sorted
* ^
*
*/
def be(sortedWord: SortedWord) =
outerInstance.or(MatcherWords.not.be(sortedWord))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be readable
* ^
*
*/
def be(readableWord: ReadableWord) =
outerInstance.or(MatcherWords.not.be(readableWord))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be empty
* ^
*
*/
def be(emptyWord: EmptyWord) =
outerInstance.or(MatcherWords.not.be(emptyWord))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be writable
* ^
*
*/
def be(writableWord: WritableWord) =
outerInstance.or(MatcherWords.not.be(writableWord))
/**
* This method enables the following syntax:
*
*
* aMatcher or not be defined
* ^
*
*/
def be(definedWord: DefinedWord) =
outerInstance.or(MatcherWords.not.be(definedWord))
/**
* This method enables the following syntax:
*
*
* aMatcher or not fullyMatch regex (decimal)
* ^
*
*/
def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.or(MatcherWords.not.fullyMatch(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher or not include regex (decimal)
* ^
*
*/
def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.or(MatcherWords.not.include(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher or not include ("1.7")
* ^
*
*/
def include(expectedSubstring: String): Matcher[T with String] =
outerInstance.or(MatcherWords.not.include(expectedSubstring))
/**
* This method enables the following syntax:
*
*
* aMatcher or not startWith regex (decimal)
* ^
*
*/
def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.or(MatcherWords.not.startWith(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher or not startWith ("1.7")
* ^
*
*/
def startWith(expectedSubstring: String): Matcher[T with String] =
outerInstance.or(MatcherWords.not.startWith(expectedSubstring))
/**
* This method enables the following syntax:
*
*
* aMatcher or not endWith regex (decimal)
* ^
*
*/
def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String] =
outerInstance.or(MatcherWords.not.endWith(resultOfRegexWordApplication))
/**
* This method enables the following syntax:
*
*
* aMatcher or not endWith ("1.7")
* ^
*
*/
def endWith(expectedSubstring: String): Matcher[T with String] =
outerInstance.or(MatcherWords.not.endWith(expectedSubstring))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain (3)
* ^
*
*/
def contain[U](expectedElement: U): MatcherFactory1[T, Containing] =
outerInstance.or(MatcherWords.not.contain(expectedElement))
/**
* This method enables the following syntax:
*
*
* Map("one" -> 1, "two" -> 2) should (not contain key ("two") or not contain key ("three"))
* ^
*
*/
/*
def contain[U](resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping] =
outerInstance.or(MatcherWords.not.contain(resultOfKeyWordApplication))
*/
// TODO: Tests and implementation
/**
* This method enables the following syntax:
*
*
* Map("one" -> 1, "two" -> 2) should (not contain value (2) or not contain value (3))
* ^
*
*/
/*
def contain[U](resultOfValueWordApplication: ResultOfValueWordApplication[U]): MatcherFactory1[T, ValueMapping] =
outerInstance.or(MatcherWords.not.contain(resultOfValueWordApplication))
*/
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain oneOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfOneOfApplication): MatcherFactory1[T, Containing] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain atLeastOneOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain noneOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfNoneOfApplication): MatcherFactory1[T, Containing] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain theSameElementsAs (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain theSameElementsInOrderAs (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[T, Sequencing] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain inOrderOnly (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory1[T, Sequencing] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain only (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfOnlyApplication): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain allOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfAllOfApplication): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain inOrder (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfInOrderApplication): MatcherFactory1[T, Sequencing] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax:
*
*
* aMatcher not contain atMostOneOf (8, 1, 2)
* ^
*
*/
def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory1[T, Aggregating] =
outerInstance.or(MatcherWords.not.contain(right))
/**
* This method enables the following syntax given a Matcher:
*
*
* aMatcher or not contain key ("three")
* ^
*
*/
def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping] =
outerInstance.or(MatcherWords.not.contain(resultOfKeyWordApplication))
/**
* This method enables the following syntax given a Matcher:
*
*
* aMatcher or not contain value (3)
* ^
*
*/
def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[T, ValueMapping] =
outerInstance.or(MatcherWords.not.contain(resultOfValueWordApplication))
}
/**
* This method enables the following syntax:
*
*
* aMatcher or not contain value (3)
* ^
*
*/
def or(notWord: NotWord): OrNotWord = new OrNotWord
/**
* This method enables the following syntax:
*
*
* aMatcher or exist
* ^
*
*/
def or(existWord: ExistWord): MatcherFactory1[T, Existence] =
outerInstance.or(MatcherWords.exist.matcherFactory)
/**
* This method enables the following syntax:
*
*
* aMatcher or not (exist)
* ^
*
*/
def or(notExist: ResultOfNotExist): MatcherFactory1[T, Existence] =
outerInstance.or(MatcherWords.not.exist)
/**
* Create a new Matcher that will produce MatchResult by applying original MatchResult
* produced by this Matcher to the passed m2m function. In other words, the MatchResult
* produced by this Matcher will be passed to m2m to produce the final MatchResult
*
* @param m2m a function to apply to the original MatchResult produced by this Matcher
* @return a new Matcher that will produce MatchResult by applying original MatchResult
* produced by this Matcher to the passed m2m function
*/
def mapResult(m2m: MatchResult => MatchResult): Matcher[T] =
new Matcher[T] {
def apply(o: T): MatchResult = m2m(outerInstance(o))
}
/**
* Create a new Matcher that will produce MatchResult that contains error messages constructed
* using arguments that are transformed by the passed a2s function. In other words, the MatchResult
* produced by this Matcher will use arguments transformed by a2s function to construct the final
* error messages.
*
* @param a2s a function to transform arguments of error messages.
* @return a new Matcher that will produce MatchResult that contains error messages constructed
* using arguments that are transformed by the passed a2s function.
*/
def mapArgs(a2s: Any => String): Matcher[T] =
new Matcher[T] {
def apply(o: T): MatchResult = {
val mr = outerInstance(o)
mr.copy(
failureMessageArgs = mr.failureMessageArgs.map((LazyArg(_) { a2s })),
negatedFailureMessageArgs = mr.negatedFailureMessageArgs.map((LazyArg(_) { a2s })),
midSentenceFailureMessageArgs = mr.midSentenceFailureMessageArgs.map((LazyArg(_) { a2s })),
midSentenceNegatedFailureMessageArgs = mr.midSentenceNegatedFailureMessageArgs.map((LazyArg(_) { a2s }))
)
}
}
}
/**
* Companion object for trait Matcher that provides a
* factory method that creates a Matcher[T] from a
* passed function of type (T => MatchResult).
*
* @author Bill Venners
*/
object Matcher {
/**
* Factory method that creates a Matcher[T] from a
* passed function of type (T => MatchResult).
*
* @author Bill Venners
*/
def apply[T](fun: T => MatchResult)(implicit ev: Manifest[T]): Matcher[T] =
new Matcher[T] {
def apply(left: T) = fun(left)
override def toString: String = "Matcher[" + ev.erasure.getName + "](" + ev.erasure.getName + " => MatchResult)"
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy