ParserMatchers

val parsers : Parsers

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

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

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

def getClass (): java.lang.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

def isInstanceOf [T0] : Boolean

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

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

match if the input is successfully parsed

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]

def wait (): Unit

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

def wait (arg0: Long): Unit