ScalaTest 3.0.6 < Back

Packages

package root

Definition Classes
root
package org

Definition Classes
root
package scalatest
ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.
ScalaTest's main traits, classes, and other members, including members supporting ScalaTest's DSL for the Scala interpreter.

Definition Classes
org
package matchers

Definition Classes
scalatest
trait Matcher[-T] extends (T) ⇒ MatchResult
Trait extended by objects that can match a value of the specified type.
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
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. For example, although you can ensure that a java.io.File has a name that ends with a particular extension like this:
```
file.getName should endWith (".txt")
```
You might prefer to create a custom Matcher[java.io.File] named endWithExtension, so you could write expressions like:
```
file should endWithExtension ("txt")
file should not endWithExtension "txt"
file should (exist and endWithExtension ("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 that need them. Here's an example:
```
import org.scalatest._
import matchers._

trait CustomMatchers {

  class FileEndsWithExtensionMatcher(expectedExtension: String) extends Matcher[java.io.File] {

    def apply(left: java.io.File) = {
      val name = left.getName
      MatchResult(
        name.endsWith(expectedExtension),
        s"""File $name did not end with extension "$expectedExtension"""",
        s"""File $name ended with extension "$expectedExtension""""
      )
    }
  }

  def endWithExtension(expectedExtension: String) = new FileEndsWithExtensionMatcher(expectedExtension)
}

// 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, FileEndsWithExtensionMatcher, and a def named endWithExtension that returns a new instance of FileEndsWithExtensionMatcher. 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 FileEndsWithExtensionMatcher matcher in this example determines success by determining if the passed java.io.File ends with the desired extension. It does this in the first argument passed to the MatchResult factory method:
```
name.endsWith(expectedExtension)
```
In other words, if the file name has the expected extension, this matcher matches. The next argument to MatchResult's factory method produces the failure message string:
```
s"""File $name did not end with extension "$expectedExtension"""",
```
For example, consider this matcher expression:
```
import org.scalatest._
import Matchers._
import java.io.File
import CustomMatchers._

new File("essay.text") should endWithExtension ("txt")
```
Because the passed java.io.File has the name essay.text, but the expected extension is "txt", the failure message would be:
```
File essay.text did not have extension "txt"
```
For more information on the fields in a MatchResult, including the subsequent field (or fields) that follow the failure message, please see the documentation for MatchResult.
Creating dynamic matchers
There are other ways to create new matchers besides defining one as shown above. For example, you might check that a file is hidden like this:
```
new File("secret.txt") should be ('hidden)
```
If you wanted to get rid of the tick mark, you could simply define hidden like this:
```
val hidden = 'hidden
```
Now you can check that an file is hidden without the tick mark:
```
new File("secret.txt") should be (hidden)
```
You could get rid of the parens with by using shouldBe:
```
new File("secret.txt") shouldBe hidden
```
Creating matchers using logical operators
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)
```
Composing matchers
You can also compose matchers. For example, the endWithExtension matcher from the example above can be more easily created by composing a function with the existing endWith matcher:
```
scala> import org.scalatest._
import org.scalatest._

scala> import Matchers._
import Matchers._

scala> import java.io.File
import java.io.File

scala> def endWithExtension(ext: String) = endWith(ext) compose { (f: File) => f.getPath }
endWithExtension: (ext: String)org.scalatest.matchers.Matcher[java.io.File]
```
Now you have a Matcher[File] whose apply method first invokes the converter function to convert the passed File to a String, then passes the resulting String to endWith. Thus, you could use this version endWithExtension like the previous one:
```
scala> new File("output.txt") should endWithExtension("txt")
```
In addition, by composing twice, you can modify the type of both sides of a match statement with the same function, like this:
```
scala> val f = be > (_: Int)
f: Int => org.scalatest.matchers.Matcher[Int] = <function1>

scala> val g = (_: String).toInt
g: String => Int = <function1>

scala> val beAsIntsGreaterThan = (f compose g) andThen (_ compose g)
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>

scala> "8" should beAsIntsGreaterThan ("7")
```
At thsi point, however, the error message for the beAsIntsGreaterThan gives no hint that the Ints being compared were parsed from Strings:
```
scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
```
To modify error message, you can use trait MatcherProducers, which also provides a composeTwice method that performs the compose ... andThen ... compose operation:
```
scala> import matchers._
import matchers._

scala> import MatcherProducers._
import MatcherProducers._

scala> val beAsIntsGreaterThan = f composeTwice g // means: (f compose g) andThen (_ compose g)
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>

scala> "8" should beAsIntsGreaterThan ("7")
```
Of course, the error messages is still the same:
```
scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
```
To modify the error messages, you can use mapResult from MatcherProducers. Here's an example:
```
scala> val beAsIntsGreaterThan =
  f composeTwice g mapResult { mr =>
    mr.copy(
      failureMessageArgs =
        mr.failureMessageArgs.map((LazyArg(_) { "\"" + _.toString + "\".toInt"})),
      negatedFailureMessageArgs =
        mr.negatedFailureMessageArgs.map((LazyArg(_) { "\"" + _.toString + "\".toInt"})),
      midSentenceFailureMessageArgs =
        mr.midSentenceFailureMessageArgs.map((LazyArg(_) { "\"" + _.toString + "\".toInt"})),
      midSentenceNegatedFailureMessageArgs =
        mr.midSentenceNegatedFailureMessageArgs.map((LazyArg(_) { "\"" + _.toString + "\".toInt"}))
    )
  }
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>
```
The mapResult method takes a function that accepts a MatchResult and produces a new MatchResult, which can contain modified arguments and modified error messages. In this example, the error messages are being modified by wrapping the old arguments in LazyArg instances that lazily apply the given prettification functions to the toString result of the old args. Now the error message is clearer:
```
scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: "7".toInt was not greater than "8".toInt
```
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 Matchers, 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].
Definition Classes
matchers
AndBeWord
AndContainWord
AndEndWithWord
AndFullyMatchWord
AndHaveWord
AndIncludeWord
AndNotWord
AndStartWithWord
OrBeWord
OrContainWord
OrEndWithWord
OrFullyMatchWord
OrHaveWord
OrIncludeWord
OrNotWord
OrStartWithWord

org.scalatest.matchers.Matcher

AndNotWord

final class AndNotWord extends AnyRef

This class is part of the ScalaTest matchers DSL. Please see the documentation for Matchers for an overview of the matchers DSL.

Source: Matcher.scala

Linear Supertypes

AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

AndNotWord
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Instance Constructors

new AndNotWord()

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def be(definedWord: DefinedWord): MatcherFactory1[T, Definition]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be defined
                 ^
```
def be(emptyWord: EmptyWord): MatcherFactory1[T, Emptiness]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be empty
                 ^
```
def be(writableWord: WritableWord): MatcherFactory1[T, Writability]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be writable
                 ^
```
def be(readableWord: ReadableWord): MatcherFactory1[T, Readability]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be readable
                 ^
```
def be(sortedWord: SortedWord): MatcherFactory1[T, Sortable]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be sorted
                 ^
```
def be[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[T with U]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be definedAt (8)
                 ^
```
def be[U](spread: Spread[U]): Matcher[T with U]
This method enables the following syntax, for the "primitive" numeric types:
This method enables the following syntax, for the "primitive" numeric types:
```
aMatcher and not be (17.0 +- 0.2)
                 ^
```
def be(resultOfTheSameInstanceAsApplication: ResultOfTheSameInstanceAsApplication): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be theSameInstanceAs (otherString)
                 ^
```
macro def be(anType: ResultOfAnTypeInvocation[_]): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be an [Apple]
                 ^
```
macro def be(aType: ResultOfATypeInvocation[_]): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be a [Book]
                 ^
```
def be[U](resultOfAnWordApplication: ResultOfAnWordToAnMatcherApplication[U]): Matcher[T with U]
This method enables the following syntax, where invalidMarks is an AnMatcher:
This method enables the following syntax, where invalidMarks is an AnMatcher:
```
aMatcher and not be an (invalidMarks)
                 ^
```
def be[T <: AnyRef](resultOfAnWordApplication: ResultOfAnWordToBePropertyMatcherApplication[T]): Matcher[T with T]
This method enables the following syntax, where directory is a BePropertyMatcher:
This method enables the following syntax, where directory is a BePropertyMatcher:
```
aMatcher and not be an (directory)
                 ^
```
def be(resultOfAnWordApplication: ResultOfAnWordToSymbolApplication): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be an ('apple)
                 ^
```
def be[U <: AnyRef](resultOfAWordApplication: ResultOfAWordToBePropertyMatcherApplication[U]): Matcher[T with U]
This method enables the following syntax, where directory is a BePropertyMatcher:
This method enables the following syntax, where directory is a BePropertyMatcher:
```
aMatcher and not be a (directory)
                 ^
```
def be[U](resultOfAWordApplication: ResultOfAWordToAMatcherApplication[U]): Matcher[T with U]
This method enables the following syntax, where validMarks is an AMatcher:
This method enables the following syntax, where validMarks is an AMatcher:
```
aMatcher and not be a (validMarks)
                 ^
```
def be(resultOfAWordApplication: ResultOfAWordToSymbolApplication): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be a ('file)
                 ^
```
def be[U](bePropertyMatcher: BePropertyMatcher[U]): Matcher[T with U]
This method enables the following syntax, where directory is a BePropertyMatcher:
This method enables the following syntax, where directory is a BePropertyMatcher:
```
aMatcher and not be (directory)
                 ^
```
def be[U](beMatcher: BeMatcher[U]): Matcher[T with U]
This method enables the following syntax, where odd is a BeMatcher:
This method enables the following syntax, where odd is a BeMatcher:
```
aMatcher and not be (odd)
                 ^
```
def be(symbol: Symbol): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be ('empty)
                 ^
```
def be(tripleEqualsInvocation: TripleEqualsInvocation[_]): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be === (6)
                 ^
```
def be[U](resultOfGreaterThanOrEqualToComparison: ResultOfGreaterThanOrEqualToComparison[U]): Matcher[T with U]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be >= (6)
                 ^
```
def be[U](resultOfLessThanOrEqualToComparison: ResultOfLessThanOrEqualToComparison[U]): Matcher[T with U]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be <= (2)
                 ^
```
def be[U](resultOfGreaterThanComparison: ResultOfGreaterThanComparison[U]): Matcher[T with U]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be > (6)
                 ^
```
def be(o: Null): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be (null)
                 ^
```
def be[U](resultOfLessThanComparison: ResultOfLessThanComparison[U]): Matcher[T with U]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be < (6)
                 ^
```
def be(any: Any): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not be (3 - 1)
                 ^
```
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@native() @throws( ... )
def contain(resultOfValueWordApplication: ResultOfValueWordApplication): MatcherFactory1[T, ValueMapping]
This method enables the following syntax given a Matcher:
This method enables the following syntax given a Matcher:
```
aMatcher and not contain value (3)
                 ^
```
def contain(resultOfKeyWordApplication: ResultOfKeyWordApplication): MatcherFactory1[T, KeyMapping]
This method enables the following syntax given a Matcher:
This method enables the following syntax given a Matcher:
```
aMatcher and not contain key ("three")
                 ^
```
def contain(right: ResultOfAtMostOneElementOfApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain atMostOneOf (List(8, 1, 2))
                         ^
```
def contain(right: ResultOfAtMostOneOfApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain atMostOneOf (8, 1, 2)
                         ^
```
def contain(right: ResultOfInOrderElementsOfApplication): MatcherFactory1[T, Sequencing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain inOrderElementsOf (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfInOrderApplication): MatcherFactory1[T, Sequencing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain inOrder (8, 1, 2)
                 ^
```
def contain(right: ResultOfAllElementsOfApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain allElementsOf (8, 1, 2)
                 ^
```
def contain(right: ResultOfAllOfApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain allOf (8, 1, 2)
                 ^
```
def contain(right: ResultOfInOrderOnlyApplication): MatcherFactory1[T, Sequencing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain inOrderOnly (8, 1, 2)
                 ^
```
def contain(right: ResultOfOnlyApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain only (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfTheSameElementsInOrderAsApplication): MatcherFactory1[T, Sequencing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain theSameElementsInOrderAs (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfTheSameElementsAsApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain theSameElementsAs (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfNoElementsOfApplication): MatcherFactory1[T, Containing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain noElementsOf (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfNoneOfApplication): MatcherFactory1[T, Containing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain noneOf (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfAtLeastOneElementOfApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain atLeastOneElementOf (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfAtLeastOneOfApplication): MatcherFactory1[T, Aggregating]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain atLeastOneOf (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfOneElementOfApplication): MatcherFactory1[T, Containing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain oneElementOf (List(8, 1, 2))
                 ^
```
def contain(right: ResultOfOneOfApplication): MatcherFactory1[T, Containing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain oneOf (List(8, 1, 2))
                 ^
```
def contain[U](expectedElement: U): MatcherFactory1[T, Containing]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not contain (3)
                 ^
```
def endWith(expectedSubstring: String): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not endWith ("1.7")
                 ^
```
def endWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not endWith regex (decimal)
                 ^
```
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equal(o: Null): Matcher[T]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not equal (null)
                 ^
```
def equal[U](spread: Spread[U]): Matcher[T with U]
This method enables the following syntax, for the "primitive" numeric types:
This method enables the following syntax, for the "primitive" numeric types:
```
aMatcher and not equal (17.0 +- 0.2)
                 ^
```
def equal(any: Any): MatcherFactory1[T, Equality]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not equal (3 - 1)
                 ^
```
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fullyMatch(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not fullyMatch regex (decimal)
                 ^
```
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
def have[U](firstPropertyMatcher: HavePropertyMatcher[U, _], propertyMatchers: HavePropertyMatcher[U, _]*): Matcher[T with U]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not have (author ("Melville"))
                 ^
```
def have(resultOfMessageWordApplication: ResultOfMessageWordApplication): MatcherFactory1[T, Messaging]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not have message ("Message from Mars!")
                 ^
```
def have(resultOfSizeWordApplication: ResultOfSizeWordApplication): MatcherFactory1[T, Size]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not have size (3)
                 ^
```
def have(resultOfLengthWordApplication: ResultOfLengthWordApplication): MatcherFactory1[T, Length]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not have length (3)
                 ^
```
def include(expectedSubstring: String): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not include ("1.7")
                 ^
```
def include(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not include regex (decimal)
                 ^
```
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
macro def matchPattern(right: PartialFunction[Any, _]): Matcher[Any]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not matchPattern { case Person("Bob", _) =>}
                 ^
```
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
val owner: Matcher[T]
Get the Matcher instance, currently used by macro only.
def startWith(expectedSubstring: String): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not startWith ("1.7")
                 ^
```
def startWith(resultOfRegexWordApplication: ResultOfRegexWordApplication): Matcher[T with String]
This method enables the following syntax:
This method enables the following syntax:
```
aMatcher and not startWith regex (decimal)
                 ^
```
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@native() @throws( ... )

Packages

Creating custom matchers

Creating dynamic matchers

Creating matchers using logical operators

Composing matchers

Matcher's variance

AndNotWord

final class AndNotWord extends AnyRef

Instance Constructors

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Creating custom matchers

Creating dynamic matchers

Creating matchers using logical operators

Composing matchers

Matcher's variance

AndNotWord 

final class AndNotWord extends AnyRef

Instance Constructors

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

AndNotWord