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]]

final def asInstanceOf[T0]: T0

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

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 failOn[T](input: Input): ParseNoSuccessMatcher[T, Parser[T], Failure]

match if the input is not successfully parsed

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

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 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

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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 toParsedResultMatcher[T](result: MatchResult[ParseResult[T]]): ParsedResultMatcher[T]

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

def toString(): String

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit