BeWord

Field	Method	"is" Method	Result
			Throws `TestFailedException`, because no candidates found
		`isEmpty()`	Invokes `isEmpty()`
	`empty()`		Invokes `empty()`
	`empty()`	`isEmpty()`	Invokes `empty()` (this can occur when `BeanProperty` annotation is used)
`empty`			Accesses field `empty`
`empty`		`isEmpty()`	Invokes `isEmpty()`
`empty`	`empty()`		Invokes `empty()`
`empty`	`empty()`	`isEmpty()`	Invokes `empty()` (this can occur when `BeanProperty` annotation is used)

Instance Constructors

new BeWord()

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def <[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
result should be < (7)
                 ^
```
Note that the less than operator will be invoked on be in this expression, not on a result of passing be to should, as with most other operators in the matchers DSL, because the less than operator has a higher precedence than should. Thus in the above case the first expression evaluated will be be < (7), which results in a matcher that is passed to should.
This method also enables the following syntax:
```
result should not (be < (7))
                      ^
```
def <=[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
result should be <= (7)
                 ^
```
Note that the less than or equal to operator will be invoked on be in this expression, not on a result of passing be to should, as with most other operators in the matchers DSL, because the less than or equal to operator has a higher precedence than should. Thus in the above case the first expression evaluated will be be <= (7), which results in a matcher that is passed to should.
This method also enables the following syntax:
```
result should not (be <= (7))
                      ^
```
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
result should be > (7)
                 ^
```
Note that the greater than operator will be invoked on be in this expression, not on a result of passing be to should, as with most other operators in the matchers DSL, because the greater than operator has a higher precedence than should. Thus in the above case the first expression evaluated will be be > (7), which results in a matcher that is passed to should.
This method also enables the following syntax:
```
result should not (be > (7))
                      ^
```
def >=[T](right: T)(implicit arg0: Ordering[T]): Matcher[T]

This method enables the following syntax:
This method enables the following syntax:
```
result should be >= (7)
                 ^
```
Note that the greater than or equal to operator will be invoked on be in this expression, not on a result of passing be to should, as with most other operators in the matchers DSL, because the greater than or equal to operator has a higher precedence than should. Thus in the above case the first expression evaluated will be be >= (7), which results in a matcher that is passed to should.
This method also enables the following syntax:
```
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:
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]:
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): Matcher[AnyRef]

This method enables the following syntax:
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:
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]:
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): Matcher[AnyRef]

This method enables the following syntax:
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:
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:
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:
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:
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:
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:
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:
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:
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.

This method enables be to be used for equality comparison. Here are some examples:

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:
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]:
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): Matcher[AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
set should be ('empty)
              ^
```
def apply(o: Null): Matcher[AnyRef]

This method enables the following syntax:
This method enables the following syntax:
```
result should be (null)
                 ^
```
def apply(right: Boolean): Matcher[Boolean]

This method enables the following syntax:
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:
This method enables the following syntax for the "primitive" numeric types:
```
sevenDotOh should be (7.1 plusOrMinus 0.2)
                     ^
```
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def definedAt[A, U <: PartialFunction[A, _]](right: A): Matcher[U]

This method enables the following syntax, where fraction refers to a PartialFunction:
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

Definition Classes
AnyRef
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] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

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

This method enables the following syntax:
This method enables the following syntax:
```
result should be theSameInstancreAs (anotherObject)
                 ^
```
def toString(): String

Overrides toString to return "be"
Overrides toString to return "be"

Definition Classes
BeWord → 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
@throws( ... )

Deprecated Value Members

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

The should be === syntax has been deprecated and will be removed in a future version of ScalaTest. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead. Note, the reason this was deprecated was so that === would mean only one thing in ScalaTest: a customizable, type- checkable equality comparison.
The should be === syntax has been deprecated and will be removed in a future version of ScalaTest. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead. Note, the reason this was deprecated was so that === would mean only one thing in ScalaTest: a customizable, type- checkable equality comparison.
This method enables the following syntax:
```
result should be === (7)
                 ^
```
Note that the === operator will be invoked on be in this expression, not on a result of passing be to should, as with most other operators in the matchers DSL, because the ===n operator has a higher precedence than should. Thus in the above case the first expression evaluated will be be === (7), which results in a matcher that is passed to should.
This method also enables the following syntax:
```
result should not (be === (7))
                      ^
```
Annotations
@deprecated
Deprecated
The should be === syntax has been deprecated. Please use should equal, should ===, shouldEqual, should be, or shouldBe instead.

final class BeWord extends AnyRef

Instance Constructors

new BeWord()

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

final def ==(arg0: Any): Boolean

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

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

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

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

def a(right: Symbol): Matcher[AnyRef]

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

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

def an(right: Symbol): Matcher[AnyRef]

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

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

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

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

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

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

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

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

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

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

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

def apply(right: Symbol): Matcher[AnyRef]

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

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

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

final def asInstanceOf[T0]: T0

def clone(): AnyRef

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

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]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Deprecated Value Members

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

Inherited from AnyRef

Inherited from Any

Ungrouped