ParserMatchers

abstract val parsers: Parsers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def aFailure: ParseNoSuccessMatcher[Nothing, ParseResult[Nothing], Failure]

def aParseError: ParseNoSuccessMatcher[Nothing, ParseResult[Nothing], Error]

def aPartialSuccess: ParseSuccessMatcher[Nothing, ParseResult[Nothing]]

def aSuccess: ParseSuccessMatcher[Nothing, ParseResult[Nothing]]

def allElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

Matches if all elements are matching a "like" function

def allOf[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

final def asInstanceOf[T0]: T0

def atLeast[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def atMost[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def beAFailure[T]: ParseNoSuccessMatcher[T, ParseResult[T], Failure]

match if the input is not successfully parsed

def beAPartialSuccess[T]: ParseSuccessMatcher[T, ParseResult[T]]

match if the input is successfully, but partially, parsed

def beASuccess[T]: ParseSuccessMatcher[T, ParseResult[T]]

match if the input is successfully parsed

def beAnError[T]: ParseNoSuccessMatcher[T, ParseResult[T], Error]

match if parsing the input raises an error

def beSorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]

implicit def checkableSeqIsContainCheckSeq[T](seq: Seq[T])(implicit to: (T) ⇒ ContainCheck[T]): Seq[ContainCheck[T]]

def clone(): AnyRef

def contain[T](cm: ContainWithResultSeq[T]): ContainWithResultSeq[T]

COLLECTION MATCHERS

def contain[T](check: ContainCheck[T]): ContainWithResult[T]

ELEMENTS MATCHERS

def containAllOf[T](seq: Seq[T]): ContainWithResultSeq[T]

match if a traversable contains all the elements of seq (and maybe more)

def containAnyOf[T](seq: Seq[T]): ContainWithResult[T]

match if a traversable contains one of (t1, t2)

def containMatch[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

match if traversable contains (x matches .

def containPattern[T](t: ⇒ String): Matcher[GenTraversableOnce[T]]

match if traversable contains (x matches p)

def containTheSameElementsAs[T](seq: Seq[T]): Matcher[Traversable[T]]

does a containAll comparison in both ways

implicit def downcastBeEqualTypedContainCheck[T, S >: T](check: BeEqualTypedContainCheck[T]): ContainCheck[S]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorOn[T](input: Input): ParseNoSuccessMatcher[T, Parser[T], Error]

match if parsing the input raises an error

def exactly[T](checks: ContainCheck[T]*): ContainWithResultSeq[T]

def failOn[T](input: Input): ParseNoSuccessMatcher[T, Parser[T], Failure]

match if the input is not successfully parsed

def finalize(): Unit

implicit def functionIsContainCheck[T, R](f: (T) ⇒ R)(implicit arg0: AsResult[R]): ContainCheck[T]

final def getClass(): Class[_]

def hashCode(): Int

def have[T](function: (T) ⇒ Boolean): Matcher[GenTraversableOnce[T]]

Matches if there is one element in the traversable verifying the function parameter: (traversable.exists(function(_))

def haveAllElementsLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveAllElementsLike[T, S]

Matches if all elements are matching a "like" function

def haveFailureMsg[T](result: String): Matcher[ParseResult[T]]

match if the parse fails => string match ok

def haveFailureMsg[T](m: Matcher[String]): Matcher[ParseResult[T]]

match if the parse fails => matcher ok

def haveLength[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

alias for haveSize

def haveOneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

Matches if there is at least one matching a "like" function

def haveSize[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

match if there is a way to size T

def haveSuccessResult[T](result: String): Matcher[ParseResult[T]]

match if the parse successful => string match ok

def haveSuccessResult[T](m: Matcher[T]): Matcher[ParseResult[T]]

match if the parse successful => matcher ok

def haveTheSameElementsAs[T](l: ⇒ Traversable[T], equality: (T, T) ⇒ Boolean = (_:T) == (_:T)): HaveTheSameElementsAs[T]

Matches if there l contains the same elements as the Traversable traversable.

implicit lazy val implicitParam: ImplicitParam

implicit lazy val implicitParam1: ImplicitParam1

implicit lazy val implicitParam10: ImplicitParam10

implicit lazy val implicitParam2: ImplicitParam2

implicit lazy val implicitParam3: ImplicitParam3

implicit lazy val implicitParam4: ImplicitParam4

implicit lazy val implicitParam5: ImplicitParam5

implicit lazy val implicitParam6: ImplicitParam6

implicit lazy val implicitParam7: ImplicitParam7

implicit lazy val implicitParam8: ImplicitParam8

implicit lazy val implicitParam9: ImplicitParam9

final def isInstanceOf[T0]: Boolean

implicit def javaCollectionIsSized[T <: Collection[_]]: Sized[T]

any java collection has a size

implicit def lazyfy[T](value: ⇒ T): LazyParameter[T]

transform a value to a zero-arg function returning that value

def length[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

alias for haveSize

implicit def matcherIsContainCheck[T](m: Matcher[T]): ContainCheck[T]

implicit def matcherSeqIsContainCheckSeq[T](seq: Seq[Matcher[T]]): Seq[ContainCheck[T]]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def oneElementLike[T, S](like: PartialFunction[T, MatchResult[S]]): HaveOneElementLike[T, S]

Matches if there is at least one matching a "like" function

implicit def orderedSeqMatchResult[T](result: MatchResult[Seq[T]])(implicit arg0: Ordering[T]): OrderedSeqMatchResult[T]

implicit def scalaArrayIsSized[T]: Sized[Array[T]]

any scala array has a size

implicit def scalaTraversableIsSized[I <: GenTraversable[_]]: Sized[I]

any scala collection has a size

def size[T](n: Int)(implicit arg0: Sized[T]): SizedMatcher[T]

alias for haveSize

implicit def sized[T](s: MatchResult[T])(implicit arg0: Sized[T]): HasSize[T]

def sorted[T](implicit arg0: Ordering[T]): OrderingMatcher[T]

alias for beSorted

implicit def stringIsSized: Sized[String]

a regular string has a size, without having to be converted to an Traversable

implicit def stringMatcherIsTraversableMatcher(m: Matcher[String]): Matcher[GenTraversableOnce[String]]

this allows the contain(string) matcher for StringMatchers to be used with a Traversable

def succeedOn[T](input: Input): ParseSuccessMatcher[T, Parser[T]]

match if the input is successfully parsed

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

implicit def timesFor(n: Int): Times

This implicit definition allows to declare a number of times 3.times

implicit def toParsedResultMatcher[T](result: MatchResult[ParseResult[T]]): ParsedResultMatcher[T]

implicit def toParserResultMatcherResult[T](result: MatchResult[Parser[T]]): ParserResultMatcherResult[T]

def toString(): String

implicit def traversable[T](s: MatchResult[Traversable[T]]): TraversableBeHaveMatchers[T]

implicit def useStringsAsInput(s: String): Reader[Char]

implicit def valueIsTypedContainCheck[T](expected: T): BeEqualTypedContainCheck[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit