LogicWordSpecStringWrapper

A class that via an implicit conversion (named convertToLogicWordSpecStringWrapper) enables methods when, which, in, is, taggedAs and ignore to be invoked on Strings.

This class provides much of the syntax for LogicWordSpec, however, it does not add the verb methods (should, must, and can) to String. Instead, these are added via the ShouldVerb, MustVerb, and CanVerb traits, which LogicWordSpec mixes in, to avoid a conflict with implicit conversions provided in Matchers and MustMatchers.

Attributes: protected
Source: LogicWordSpecLike.scala

Linear Supertypes

AnyRef, Any

Instance Constructors

new LogicWordSpecStringWrapper(string: String)

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 clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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
def ignore(f: ⇒ Assertion)(implicit pos: Position): Unit

Supports ignored test registration.
Supports ignored test registration.
For example, this method supports syntax such as the following:
```
"complain on peek" ignore { ... }
                   ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def in(f: ⇒ Assertion)(implicit pos: Position): Unit

Supports test registration.
Supports test registration.
For example, this method supports syntax such as the following:
```
"complain on peek" in { ... }
                   ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def is(f: ⇒ PendingStatement)(implicit pos: Position): Unit

Supports pending test registration.
Supports pending test registration.
For example, this method supports syntax such as the following:
```
"complain on peek" is (pending)
                   ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
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 taggedAs(firstTestTag: Tag, otherTestTags: Tag*): ResultOfTaggedAsInvocationOnString

Supports tagged test registration.
Supports tagged test registration.
For example, this method supports syntax such as the following:
```
"complain on peek" taggedAs(SlowTest) in { ... }
                   ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def that(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit pos: Position): Unit

Registers a that clause that is followed by an after word.
Registers a that clause that is followed by an after word.
For example, this method supports syntax such as the following:
```
def is = afterWord("is")

"a rerun button" that is {
                 ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def that(f: ⇒ Unit)(implicit pos: Position): Unit

Registers a that clause.
Registers a that clause.
For example, this method supports syntax such as the following:
```
"a rerun button" that {
                 ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
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
@throws( ... )
def when(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit pos: Position): Unit

Registers a when clause that is followed by an after word.
Registers a when clause that is followed by an after word.
For example, this method supports syntax such as the following:
```
val theUser = afterWord("the user")

"A Stack" when theUser { ... }
          ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def when(f: ⇒ Unit)(implicit pos: Position): Unit

Registers a when clause.
Registers a when clause.
For example, this method supports syntax such as the following:
```
"A Stack" when { ... }
          ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def which(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit pos: Position): Unit

Registers a which clause that is followed by an after word.
Registers a which clause that is followed by an after word.
For example, this method supports syntax such as the following:
```
def is = afterWord("is")

"a rerun button," which is {
                 ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.
def which(f: ⇒ Unit)(implicit pos: Position): Unit

Registers a which clause.
Registers a which clause.
For example, this method supports syntax such as the following:
```
"a rerun button," which {
                 ^
```
For more information and examples of this method's use, see the main documentation for trait LogicWordSpec.

Related Doc: package LogicWordSpecLike

final class LogicWordSpecStringWrapper extends AnyRef

Instance Constructors

new LogicWordSpecStringWrapper(string: String)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def ignore(f: ⇒ Assertion)(implicit pos: Position): Unit

def in(f: ⇒ Assertion)(implicit pos: Position): Unit

def is(f: ⇒ PendingStatement)(implicit pos: Position): Unit

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 taggedAs(firstTestTag: Tag, otherTestTags: Tag*): ResultOfTaggedAsInvocationOnString

def that(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit pos: Position): Unit

def that(f: ⇒ Unit)(implicit pos: Position): Unit

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def when(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit pos: Position): Unit

def when(f: ⇒ Unit)(implicit pos: Position): Unit

def which(resultOfAfterWordApplication: ResultOfAfterWordApplication)(implicit pos: Position): Unit

def which(f: ⇒ Unit)(implicit pos: Position): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped