BeWord

final def !=(arg0: Any): Boolean

final def ##(): Int

def <[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:

result should be < (7)
                 ^

result should not (be < (7))
                      ^

def <=[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:

result should be <= (7)
                 ^

result should not (be <= (7))
                      ^

final def ==(arg0: Any): Boolean

def >[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:

result should be > (7)
                 ^

result should not (be > (7))
                      ^

def >=[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:

result should be >= (7)
                 ^

result should not (be >= (7))
                      ^

def a[S](aMatcher: AMatcher[S]): Matcher[S]

This method enables the following syntax, where negativeNumber is, for example, of type AMatcher:

8 should not { be a (negativeNumber) }
                  ^

def a[S <: AnyRef](bePropertyMatcher: BePropertyMatcher[S]): Matcher[S]

This method enables the following syntax, where fileMock is, for example, of type File and file refers to a BePropertyMatcher[File]:

fileMock should not { be a (file) }
                         ^

def a(right: Symbol)(implicit prettifier: Prettifier, pos: Position): Matcher[AnyRef]

This method enables the following syntax:

fileMock should not { be a ('file) }
                         ^

def an[S](anMatcher: AnMatcher[S]): Matcher[S]

This method enables the following syntax, where oddNumber is, for example, of type AnMatcher:

8 should not { be an (oddNumber) }
                  ^

def an[S <: AnyRef](bePropertyMatcher: BePropertyMatcher[S]): Matcher[S]

This method enables the following syntax, where keyEvent is, for example, of type KeyEvent and actionKey refers to a BePropertyMatcher[KeyEvent]:

keyEvent should not { be an (actionKey) }
                         ^

def an(right: Symbol)(implicit prettifier: Prettifier, pos: Position): Matcher[AnyRef]

This method enables the following syntax:

animal should not { be an ('elephant) }
                       ^

def apply(defined: DefinedWord): MatcherFactory1[Any, Definition]

This method enables syntax such as the following:

array should be (defined)
                ^

def apply(empty: EmptyWord): MatcherFactory1[Any, Emptiness]

This method enables syntax such as the following:

array should be (empty)
                ^

def apply(writable: WritableWord): MatcherFactory1[Any, Writability]

This method enables the following syntax, where open refers to a BePropertyMatcher:

file should be (writable)
                ^

def apply(readable: ReadableWord): MatcherFactory1[Any, Readability]

This method enables the following syntax, where open refers to a BePropertyMatcher:

file should be (readable)
               ^

macro def apply(anType: ResultOfAnTypeInvocation[_]): Matcher[Any]

This method enables the following syntax, where open refers to a BePropertyMatcher:

result should be (an [Book])
              ^

macro def apply(aType: ResultOfATypeInvocation[_]): Matcher[Any]

This method enables the following syntax, where open refers to a BePropertyMatcher:

result should be (a [Book])
              ^

def apply[A, U <: PartialFunction[A, _]](resultOfDefinedAt: ResultOfDefinedAt[A]): Matcher[U]

This method enables the following syntax, where fraction refers to a PartialFunction:

fraction should (be (definedAt (6)) and be (definedAt (8)))
                 ^

def apply(right: SortedWord): MatcherFactory1[Any, Sortable]

This method enables the following syntax, where open refers to a BePropertyMatcher:

List(1, 2, 3) should be (sorted)
                         ^

def apply(right: Any): Matcher[Any]

This method enables be to be used for equality comparison.

result should be (None)
                 ^
result should be (Some(1))
                 ^
result should be (true)
                 ^
result should be (false)
                 ^
sum should be (19)
              ^

def apply[T](bePropertyMatcher: BePropertyMatcher[T]): Matcher[T]

This method enables the following syntax, where open refers to a BePropertyMatcher:

door should be (open)
               ^

def apply[T](right: BeMatcher[T]): Matcher[T]

This method enables the following syntax, where num is, for example, of type Int and odd refers to a BeMatcher[Int]:

num should be (odd)
              ^

def apply(right: Symbol)(implicit prettifier: Prettifier, pos: Position): Matcher[AnyRef]

This method enables the following syntax:

set should be ('empty)
              ^

def apply(o: Null): Matcher[AnyRef]

This method enables the following syntax:

result should be (null)
                 ^

def apply(right: Boolean): Matcher[Boolean]

This method enables the following syntax:

result should be (true)
                 ^

def apply[U](spread: Spread[U]): Matcher[U]

This method enables the following syntax for the "primitive" numeric types:

sevenDotOh should be (7.1 +- 0.2)
                     ^

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def definedAt[A, U <: PartialFunction[A, _]](right: A): Matcher[U]

This method enables the following syntax, where fraction refers to a PartialFunction:

fraction should (be definedAt (6) and be definedAt (8))
                    ^

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def theSameInstanceAs(right: AnyRef): Matcher[AnyRef]

This method enables the following syntax:

result should be theSameInstancreAs (anotherObject)
                 ^

def thrownBy(code: ⇒ Unit): ResultOfBeThrownBy

This method enables the following syntax:

a[Exception] should (be thrownBy { "hi".charAt(-1) })
                        ^

def toString(): String

Overrides toString to return "be"

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def ===(right: Any)(implicit pos: Position): Matcher[Any]

The deprecation period for the "be ===" syntax has expired, and the syntax will now throw NotAllowedException. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.