StringMatchers

final def !=(arg0: Any): Boolean

def !=/(s: String): Matcher[Any]

matches if a.toLowerCase.trim != b.toLowerCase.trim

final def ##(): Int

final def ==(arg0: Any): Boolean

def ==/(s: String): AdaptableMatcher[Any]

matches if a.toLowerCase.trim = b.toLowerCase.trim

def =~(r: Regex): BeMatchingRegex

alias for beMatching but matching just a fragment of the string

def =~(p: Pattern): BeMatchingPattern

alias for beMatching but matching just a fragment of the string

def =~(t: ⇒ String): BeMatching

alias for beMatching but matching just a fragment of the string

final def asInstanceOf[T0]: T0

def be: NeutralMatcher[Any]

def beMatching(a: Regex): BeMatchingRegex

matches if b matches the regex a

def beMatching(a: Pattern): BeMatchingPattern

matches if b matches the pattern a

def beMatching(a: ⇒ String): BeMatching

matches if b matches the regular expression a

def be_!=/(a: String): Matcher[Any]

matches if a.toLowerCase.trim != b.toLowerCase.trim

def be_==/(a: String): AdaptableMatcher[Any]

matches if a.toLowerCase.trim = b.toLowerCase.trim

def clone(): AnyRef

def contain(t: Char): Matcher[String]

matches if (b contains a)

def contain(t: String): Matcher[String]

matches if (b contains a)

def containing(s: String): Matcher[String]

def endWith(t: ⇒ String): Matcher[String]

matches if b.endsWith(a)

def endingWith(s: ⇒ String): Matcher[String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def find(r: Regex): FindMatcherRegex

matches if the regexp r is found inside b

def find(p: Pattern): FindMatcherPattern

matches if the pattern p is found inside b

def find(a: ⇒ String): FindMatcher

matches if the regexp a is found inside b

final def getClass(): Class[_]

def hashCode(): Int

def have: NeutralMatcher[Any]

final def isInstanceOf[T0]: Boolean

def matching(r: Regex): BeMatchingRegex

def matching(t: Pattern): BeMatchingPattern

def matching(t: ⇒ String): BeMatching

final def ne(arg0: AnyRef): Boolean

def not: NotMatcher[Any]

final def notify(): Unit

final def notifyAll(): Unit

def startWith(a: String): Matcher[String]

matches if b.startsWith(a)

def startingWith(s: ⇒ String): Matcher[String]

implicit def stringMatcher(m: AdaptableMatcher[Any]): StringMatcher

adapt the BeEqualTo matcher to provide ignoreCase and ignoreSpace matcher

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

implicit def toNeutralStringMatcher(result: NeutralMatcher[Any]): NeutralStringMatcher

implicit def toNotStringMatcher(result: NotMatcher[Any]): NotStringMatcher

def toString(): String

implicit def toStringResultMatcher(result: MatchResult[String]): StringResultMatcher

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit