ScalaTest 1.0
|
|
org/scalatest/matchers/Matchers.scala
]
final
class
NotWord
extends
AnyRefShouldMatchers
or MustMatchers
for an overview of
the matchers DSL.Method Summary | |
def
|
apply
[S](matcher : Matcher[S]) : Matcher[S]
This method enables the following syntax, where
tempFile , for example, refers to a java.io.File
and exist is a Matcher[java.io.File] :
tempFile should not (exist) ^ |
def
|
apply
[S](beMatcher : BeMatcher[S]) : BeMatcher[S]
This method enables any
BeMatcher to be negated by passing it to not .
For example, if you have a BeMatcher[Int] called odd , which matches
Int s that are odd, you can negate it to get a BeMatcher[Int] that matches
even Int s, like this:
val even = not (odd) ^ |
def
|
be
[T <: AnyRef](resultOfAWordApplication : ResultOfAWordToSymbolApplication) : Matcher[T]
This method enables the following syntax:
isNotFileMock should (not be a ('file) and have ('name ("temp.txt")))) ^ |
def
|
be
[T <: AnyRef](symbol : scala.Symbol) : Matcher[T]
This method enables the following syntax:
myFile should (not be ('hidden) and have (name ("temp.txt"))) ^ |
def
|
be
[T](resultOfGreaterThanOrEqualToComparison : ResultOfGreaterThanOrEqualToComparison[T]) : Matcher[T]
This method enables the following syntax:
num should (not be >= (10) and not be < (7)) ^ |
def
|
be
(o : Null) : Matcher[AnyRef]
This method enables the following syntax:
map should (not be (null)) ^ |
def
|
be
(right : Any) : Matcher[Any]
This method enables
be to be used for inequality comparison. Here are some examples:
object should not be (None) ^ object should not be (Some(1)) ^ result should not be (true) ^ result should not be (false) ^ sum should not be (19) ^ |
def
|
be
[T <: AnyRef](resultOfAnWordApplication : ResultOfAnWordToBePropertyMatcherApplication[T]) : Matcher[T]
This method enables the following syntax:
myFile should (not be an (directory) and not be an (directory)) ^ |
def
|
be
[T <: AnyRef](bePropertyMatcher : BePropertyMatcher[T]) : Matcher[T]
This method enables the following syntax, where
tempFile , for example, refers to a java.io.File
and hidden is a BePropertyMatcher[java.io.File] :
tempFile should (not be (hidden) and have ('name ("temp.txt"))) ^ |
def
|
be
[T <: AnyRef](resultOfAnWordApplication : ResultOfAnWordToSymbolApplication) : Matcher[T]
This method enables the following syntax:
isNotAppleMock should (not be an ('apple) and not be ('rotten)) ^ |
def
|
be
[T <: AnyRef](resultOfAWordApplication : ResultOfAWordToBePropertyMatcherApplication[T]) : Matcher[T]
This method enables the following syntax, where
notSoSecretFile , for example, refers to a java.io.File
and directory is a BePropertyMatcher[java.io.File] :
notSoSecretFile should (not be a (directory) and have ('name ("passwords.txt"))) ^ |
def
|
be
(doubleTolerance : DoubleTolerance) : Matcher[Double]
This method enables the following syntax:
sevenDotOh should ((not be (17.1 plusOrMinus 0.2)) and (not be (27.1 plusOrMinus 0.2))) ^ |
def
|
be
(byteTolerance : ByteTolerance) : Matcher[Byte]
This method enables the following syntax:
sevenByte should ((not be (19.toByte plusOrMinus 2.toByte)) and (not be (29.toByte plusOrMinus 2.toByte))) ^ |
def
|
be
[T](beMatcher : BeMatcher[T]) : Matcher[T]
This method enables the following syntax, where, for example,
num is an Int and odd
of type BeMatcher[Int] :
num should (not be (odd) and be <= (8)) ^ |
def
|
be
(shortTolerance : ShortTolerance) : Matcher[Short]
This method enables the following syntax:
sevenShort should ((not be (19.toShort plusOrMinus 2.toShort)) and (not be (29.toShort plusOrMinus 2.toShort))) ^ |
def
|
be
[T](resultOfGreaterThanComparison : ResultOfGreaterThanComparison[T]) : Matcher[T]
This method enables the following syntax:
num should (not be > (10) and not be < (7)) ^ |
def
|
be
(intTolerance : IntTolerance) : Matcher[Int]
This method enables the following syntax:
sevenInt should ((not be (19 plusOrMinus 2)) and (not be (29 plusOrMinus 2))) ^ |
def
|
be
[T](resultOfLessThanComparison : ResultOfLessThanComparison[T]) : Matcher[T]
This method enables the following syntax:
num should (not be < (7) and not be > (10)) ^ |
def
|
be
(floatTolerance : FloatTolerance) : Matcher[Float]
This method enables the following syntax:
sevenDotOhFloat should ((not be (17.1f plusOrMinus 0.2f)) and (not be (27.1f plusOrMinus 0.2f))) ^ |
def
|
be
(longTolerance : LongTolerance) : Matcher[Long]
This method enables the following syntax:
sevenLong should ((not be (19L plusOrMinus 2L)) and (not be (29L plusOrMinus 2L))) ^ |
def
|
be
[T](resultOfLessThanOrEqualToComparison : ResultOfLessThanOrEqualToComparison[T]) : Matcher[T]
This method enables the following syntax:
num should (not be <= (7) and not be > (10)) ^ |
def
|
be
(resultOfTripleEqualsApplication : ResultOfTripleEqualsApplication) : Matcher[Any]
This method enables the following syntax:
num should (not be === (7) and not be === (10)) ^ |
def
|
be
[T <: AnyRef](resultOfTheSameInstanceAsApplication : ResultOfTheSameInstanceAsApplication) : Matcher[T]
This method enables the following syntax:
myFish should (not be theSameInstanceAs (redFish) and not be theSameInstanceAs (blueFish)) ^ |
def
|
contain
[K, V](resultOfValueWordApplication : ResultOfValueWordApplication[V]) : Matcher[scala.collection.Map[Any, V]]
This method enables the following syntax:
Map("one" -> 1, "two" -> 2) should (not contain value (3)) ^ |
def
|
contain
[T](expectedElement : T) : Matcher[scala.Iterable[T]]
This method enables the following syntax:
Array(1, 2) should (not contain (5) and not contain (3)) ^ |
def
|
contain
[K](resultOfKeyWordApplication : ResultOfKeyWordApplication[K]) : Matcher[scala.collection.Map[K, Any]]
This method enables the following syntax:
Map("one" -> 1, "two" -> 2) should (not contain key ("three")) ^ |
def
|
endWith
(expectedSubstring : java.lang.String) : Matcher[java.lang.String]
This method enables the following syntax:
string should (not endWith ("blue") and not endWith ("1.7")) ^ |
def
|
endWith
(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
This method enables the following syntax:
string should (not endWith regex ("wor.d") and not startWith regex ("Hel*o")) ^ |
def
|
equal
(right : Any) : Matcher[Any]
This method enables the following syntax:
num should (not equal (7) and be < (9)) ^ |
def
|
fullyMatch
(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
This method enables the following syntax:
string should (not fullyMatch regex ("Hel*o) and not include ("orld")) ^ |
def
|
have
(resultOfLengthWordApplication : ResultOfLengthWordApplication) : Matcher[AnyRef]
This method enables the following syntax:
Array(1, 2) should (not have length (5) and not have length (3)) ^ |
def
|
have
[T](firstPropertyMatcher : HavePropertyMatcher[T, Any], propertyMatchers : HavePropertyMatcher[T, Any]*) : Matcher[T]
This method enables the following syntax, where, for example,
book is of type Book and title and author
are both of type HavePropertyMatcher[Book, String] :
book should (not have (title ("Moby Dick")) and (not have (author ("Melville")))) ^ |
def
|
have
(resultOfSizeWordApplication : ResultOfSizeWordApplication) : Matcher[AnyRef]
This method enables the following syntax:
Array(1, 2) should (not have size (5) and not have size (3)) ^ |
def
|
include
(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
This method enables the following syntax:
string should (not include regex ("Hel.o") and not include regex ("""(-)?(\d+)(\.\d*)?""")) ^ |
def
|
include
(expectedSubstring : java.lang.String) : Matcher[java.lang.String]
This method enables the following syntax:
string should (not include ("cat") and not include ("1.7")) ^ |
def
|
startWith
(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
This method enables the following syntax:
string should (not startWith regex ("hel*o") and not endWith regex ("wor.d)) ^ |
def
|
startWith
(expectedSubstring : java.lang.String) : Matcher[java.lang.String]
This method enables the following syntax:
string should ((not startWith ("red")) and (not startWith ("1.7"))) ^ |
Methods inherited from AnyRef | |
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized |
Methods inherited from Any | |
==, !=, isInstanceOf, asInstanceOf |
Method Details |
tempFile
, for example, refers to a java.io.File
and exist
is a Matcher[java.io.File]
:
tempFile should not (exist) ^
BeMatcher
to be negated by passing it to not
.
For example, if you have a BeMatcher[Int]
called odd
, which matches
Int
s that are odd, you can negate it to get a BeMatcher[Int]
that matches
even Int
s, like this:
val even = not (odd) ^
In addition, this method enables you to negate a BeMatcher
at its point of use, like this:
Nevertheless, in such as case it would be more idiomatic to write:
num should not be (odd)num should (not equal (7) and be < (9)) ^
def
have(resultOfLengthWordApplication : ResultOfLengthWordApplication) : Matcher[AnyRef]
Array(1, 2) should (not have length (5) and not have length (3)) ^
def
have(resultOfSizeWordApplication : ResultOfSizeWordApplication) : Matcher[AnyRef]
Array(1, 2) should (not have size (5) and not have size (3)) ^
def
have[T](firstPropertyMatcher : HavePropertyMatcher[T, Any], propertyMatchers : HavePropertyMatcher[T, Any]*) : Matcher[T]
book
is of type Book
and title
and author
are both of type HavePropertyMatcher[Book, String]
:
book should (not have (title ("Moby Dick")) and (not have (author ("Melville")))) ^
num
is an Int
and odd
of type BeMatcher[Int]
:
num should (not be (odd) and be <= (8)) ^
map should (not be (null)) ^
def
be[T](resultOfLessThanComparison : ResultOfLessThanComparison[T]) : Matcher[T]
num should (not be < (7) and not be > (10)) ^
def
be[T](resultOfGreaterThanComparison : ResultOfGreaterThanComparison[T]) : Matcher[T]
num should (not be > (10) and not be < (7)) ^
def
be[T](resultOfLessThanOrEqualToComparison : ResultOfLessThanOrEqualToComparison[T]) : Matcher[T]
num should (not be <= (7) and not be > (10)) ^
def
be[T](resultOfGreaterThanOrEqualToComparison : ResultOfGreaterThanOrEqualToComparison[T]) : Matcher[T]
num should (not be >= (10) and not be < (7)) ^
def
be(resultOfTripleEqualsApplication : ResultOfTripleEqualsApplication) : Matcher[Any]
num should (not be === (7) and not be === (10)) ^
def
be[T <: AnyRef](symbol : scala.Symbol) : Matcher[T]
myFile should (not be ('hidden) and have (name ("temp.txt"))) ^
def
be[T <: AnyRef](bePropertyMatcher : BePropertyMatcher[T]) : Matcher[T]
tempFile
, for example, refers to a java.io.File
and hidden
is a BePropertyMatcher[java.io.File]
:
tempFile should (not be (hidden) and have ('name ("temp.txt"))) ^
def
be[T <: AnyRef](resultOfAWordApplication : ResultOfAWordToSymbolApplication) : Matcher[T]
isNotFileMock should (not be a ('file) and have ('name ("temp.txt")))) ^
def
be[T <: AnyRef](resultOfAWordApplication : ResultOfAWordToBePropertyMatcherApplication[T]) : Matcher[T]
notSoSecretFile
, for example, refers to a java.io.File
and directory
is a BePropertyMatcher[java.io.File]
:
notSoSecretFile should (not be a (directory) and have ('name ("passwords.txt"))) ^
def
be[T <: AnyRef](resultOfAnWordApplication : ResultOfAnWordToSymbolApplication) : Matcher[T]
isNotAppleMock should (not be an ('apple) and not be ('rotten)) ^
def
be[T <: AnyRef](resultOfAnWordApplication : ResultOfAnWordToBePropertyMatcherApplication[T]) : Matcher[T]
myFile should (not be an (directory) and not be an (directory)) ^
def
be[T <: AnyRef](resultOfTheSameInstanceAsApplication : ResultOfTheSameInstanceAsApplication) : Matcher[T]
myFish should (not be theSameInstanceAs (redFish) and not be theSameInstanceAs (blueFish)) ^
def
be(doubleTolerance : DoubleTolerance) : Matcher[Double]
sevenDotOh should ((not be (17.1 plusOrMinus 0.2)) and (not be (27.1 plusOrMinus 0.2))) ^
def
be(floatTolerance : FloatTolerance) : Matcher[Float]
sevenDotOhFloat should ((not be (17.1f plusOrMinus 0.2f)) and (not be (27.1f plusOrMinus 0.2f))) ^
def
be(longTolerance : LongTolerance) : Matcher[Long]
sevenLong should ((not be (19L plusOrMinus 2L)) and (not be (29L plusOrMinus 2L))) ^
def
be(intTolerance : IntTolerance) : Matcher[Int]
sevenInt should ((not be (19 plusOrMinus 2)) and (not be (29 plusOrMinus 2))) ^
def
be(shortTolerance : ShortTolerance) : Matcher[Short]
sevenShort should ((not be (19.toShort plusOrMinus 2.toShort)) and (not be (29.toShort plusOrMinus 2.toShort))) ^
def
be(byteTolerance : ByteTolerance) : Matcher[Byte]
sevenByte should ((not be (19.toByte plusOrMinus 2.toByte)) and (not be (29.toByte plusOrMinus 2.toByte))) ^
be
to be used for inequality comparison. Here are some examples:
object should not be (None) ^ object should not be (Some(1)) ^ result should not be (true) ^ result should not be (false) ^ sum should not be (19) ^
def
fullyMatch(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
string should (not fullyMatch regex ("Hel*o) and not include ("orld")) ^
def
include(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
string should (not include regex ("Hel.o") and not include regex ("""(-)?(\d+)(\.\d*)?""")) ^
def
include(expectedSubstring : java.lang.String) : Matcher[java.lang.String]
string should (not include ("cat") and not include ("1.7")) ^
def
startWith(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
string should (not startWith regex ("hel*o") and not endWith regex ("wor.d)) ^
def
startWith(expectedSubstring : java.lang.String) : Matcher[java.lang.String]
string should ((not startWith ("red")) and (not startWith ("1.7"))) ^
def
endWith(resultOfRegexWordApplication : ResultOfRegexWordApplication) : Matcher[java.lang.String]
string should (not endWith regex ("wor.d") and not startWith regex ("Hel*o")) ^
def
endWith(expectedSubstring : java.lang.String) : Matcher[java.lang.String]
string should (not endWith ("blue") and not endWith ("1.7")) ^
def
contain[T](expectedElement : T) : Matcher[scala.Iterable[T]]
Array(1, 2) should (not contain (5) and not contain (3)) ^
def
contain[K](resultOfKeyWordApplication : ResultOfKeyWordApplication[K]) : Matcher[scala.collection.Map[K, Any]]
Map("one" -> 1, "two" -> 2) should (not contain key ("three")) ^
def
contain[K, V](resultOfValueWordApplication : ResultOfValueWordApplication[V]) : Matcher[scala.collection.Map[Any, V]]
Map("one" -> 1, "two" -> 2) should (not contain value (3)) ^
ScalaTest 1.0
|
|