Instance Constructors
-
new
ParserTests
()
Type Members
-
type
?0
-
type
Elem
= Char
-
type
Input
= Reader[Elem]
-
type
_$4
-
type
_$4
-
type
_$4
-
type
_$5
-
type
_$5
-
type
_$5
-
type
_$6
-
type
_$6
-
type
_$6
-
type
_$7
-
type
_$7
-
type
_$7
-
type
_$8
-
type
_$8
-
type
_$8
-
type
_$9
-
type
_$9
-
type
_$9
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
##
(): Int
-
def
==
(arg0: AnyRef): Boolean
-
def
==
(arg0: Any): Boolean
-
object
FocusTest
extends Tag
-
lazy val
IDENTIFIER
: Regex
-
def
OnceParser
[T]
(f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]
-
def
Parser
[T]
(f: (Input) ⇒ ParseResult[T]): Parser[T]
-
def
accept
[U]
(expected: String, f: PartialFunction[Elem, U]): Parser[U]
-
def
accept
[ES]
(es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]
-
implicit def
accept
(e: Elem): Parser[Elem]
-
def
acceptIf
(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]
-
def
acceptMatch
[U]
(expected: String, f: PartialFunction[Elem, U]): Parser[U]
-
def
acceptSeq
[ES]
(es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]
-
def
any
: PackratParser[Char]
-
def
asInstanceOf
[T0]
: T0
-
def
assert
(o: Option[String]): Unit
-
def
assert
(o: Option[String], clue: Any): Unit
-
def
assert
(condition: Boolean, clue: Any): Unit
-
def
assert
(condition: Boolean): Unit
-
def
assertMessage
(index: Int, line: Int, column: Int, msg: String): Unit
-
def
assertParseError
[T]
(str: String, p: Parser[T], line: Int, column: Int, msg: String, iserr: Boolean): Unit
-
def
assertParseOk
[T]
(str: String, p: Parser[T], result: T): Unit
-
lazy val
assign_stmt
: Parser[AssignStmt]
-
lazy val
block
: PackratParser[Block]
-
lazy val
block_stmt
: Parser[BlockStmt]
-
lazy val
boolean_literal
: Parser[BooleanLiteral]
-
def
chainl1
[T, U]
(first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]
-
def
chainl1
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]
-
def
chainr1
[T, U]
(p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]
-
lazy val
class_decl
: Parser[ClassDecl]
-
def
clone
(): AnyRef
-
def
commit
[T]
(p: ⇒ Parser[T]): Parser[T]
-
implicit def
constToTupleFunction2
[A, B, R]
(r: (A, B) ⇒ R): (~[A, B]) ⇒ R
-
implicit def
constToTupleFunction3
[A, B, C, R]
(r: (A, B, C) ⇒ R): (~[~[A, B], C]) ⇒ R
-
implicit def
constToTupleFunction4
[A, B, C, D, R]
(r: (A, B, C, D) ⇒ R): (~[~[~[A, B], C], D]) ⇒ R
-
implicit def
constToTupleFunction5
[A, B, C, D, E, R]
(r: (A, B, C, D, E) ⇒ R): (~[~[~[~[A, B], C], D], E]) ⇒ R
-
implicit def
constToTupleFunction6
[A, B, C, D, E, F, R]
(r: (A, B, C, D, E, F) ⇒ R): (~[~[~[~[~[A, B], C], D], E], F]) ⇒ R
-
lazy val
constrainedInt
: PackratParser[Int]
-
implicit def
convertToEqualizer
(left: Any): Equalizer
-
def
elem
(e: Elem): Parser[Elem]
-
def
elem
(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]
-
def
eq
(arg0: AnyRef): Boolean
-
def
equals
(arg0: Any): Boolean
-
def
err
(msg: String): Parser[Nothing]
-
def
execute
(testName: String, configMap: Map[String, Any], color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit
-
lazy val
exp
: Parser[Exp]
-
def
expect
(expected: Any)(actual: Any): Unit
-
def
expect
(expected: Any, clue: Any)(actual: Any): Unit
-
def
expectedTestCount
(filter: Filter): Int
-
def
expectnotsame
(expected: Any)(actual: Any): Unit
-
def
expectsame
(expected: Any)(actual: Any): Unit
-
def
fail
(cause: Throwable): Nothing
-
def
fail
(message: String, cause: Throwable): Nothing
-
def
fail
(message: String): Nothing
-
def
fail
(): Nothing
-
def
failure
(msg: String): Parser[Nothing]
-
def
finalize
(): Unit
-
def
getClass
(): java.lang.Class[_]
-
def
guard
[T]
(p: ⇒ Parser[T]): Parser[T]
-
def
handleWhiteSpace
(source: CharSequence, offset: Int): Int
-
def
hashCode
(): Int
-
def
ignore
(testName: String, testTags: Tag*)(testFun: ⇒ Unit): Unit
-
implicit def
info
: Informer
-
def
intercept
[T <: AnyRef]
(f: ⇒ Any)(implicit manifest: Manifest[T]): T
-
def
isInstanceOf
[T0]
: Boolean
-
var
lastNoSuccess
: NoSuccess
-
implicit def
literal
(s: String): Parser[String]
-
def
log
[T]
(p: ⇒ Parser[T])(name: String): Parser[T]
-
def
memo
[T]
(p: Parser[T]): PackratParser[T]
-
def
mkList
[T]
: (~[T, List[T]]) ⇒ List[T]
-
lazy val
name
: PackratParser[Access]
-
def
ne
(arg0: AnyRef): Boolean
-
def
nestedSuites
: List[Suite]
-
def
not
[T]
(p: ⇒ Parser[T]): Parser[Unit]
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
def
opt
[T]
(p: ⇒ Parser[T]): Parser[Option[T]]
-
def
parse
[T]
(p: Parser[T], in: Reader): ParseResult[T]
-
def
parse
[T]
(p: Parser[T], in: CharSequence): ParseResult[T]
-
def
parse
[T]
(p: Parser[T], in: Reader[Char]): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: CharSequence): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: Reader): ParseResult[T]
-
def
parseAll
[T]
(p: Parser[T], in: Reader[Char]): ParseResult[T]
-
implicit def
parseResultToTuple2
[A, B]
(p: Parser[~[A, B]]): PackratParser[(A, B)]
-
implicit def
parseResultToTuple3
[A, B, C]
(p: Parser[~[~[A, B], C]]): PackratParser[(A, B, C)]
-
implicit def
parseResultToTuple4
[A, B, C, D]
(p: Parser[~[~[~[A, B], C], D]]): PackratParser[(A, B, C, D)]
-
implicit def
parseResultToTuple5
[A, B, C, D, E]
(p: Parser[~[~[~[~[A, B], C], D], E]]): PackratParser[(A, B, C, D, E)]
-
implicit def
parseResultToTuple6
[A, B, C, D, E, F]
(p: Parser[~[~[~[~[~[A, B], C], D], E], F]]): PackratParser[(A, B, C, D, E, F)]
-
implicit def
parser2packrat
[T]
(p: ⇒ Parser[T]): PackratParser[T]
-
def
pending
: PendingNothing
-
def
pendingUntilFixed
(f: ⇒ Unit): Unit
-
def
phrase
[T]
(p: Parser[T]): PackratParser[T]
-
def
positioned
[T <: Positional]
(p: ⇒ Parser[T]): Parser[T]
-
lazy val
posname
: Parser[Access]
-
lazy val
program
: Parser[Program]
-
implicit def
regex
(r: Regex): Parser[String]
-
def
rep
[T]
(p: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1
[T]
(first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1
[T]
(p: ⇒ Parser[T]): Parser[List[T]]
-
def
rep1sep
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]
-
def
repN
[T]
(num: Int, p: ⇒ Parser[T]): Parser[List[T]]
-
def
repsep
[T]
(p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]
-
def
result
[T]
(v: ⇒ T): Parser[T]
-
def
run
(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit
-
def
runNestedSuites
(reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit
-
def
runTest
(testName: String, reporter: Reporter, stopper: Stopper, configMap: Map[String, Any], tracker: Tracker): Unit
-
def
runTests
(testName: Option[String], reporter: Reporter, stopper: Stopper, filter: Filter, configMap: Map[String, Any], distributor: Option[Distributor], tracker: Tracker): Unit
-
def
same
(v1: Any, v2: Any): Boolean
-
def
skipWhitespace
: Boolean
-
lazy val
stmt
: PackratParser[Stmt]
-
def
stringToInt
(s: String): Either[Int, String]
-
def
success
[T]
(v: T): Parser[T]
-
def
suiteName
: String
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
tags
: Map[String, Set[String]]
-
def
test
(testName: String, testTags: Tag*)(testFun: ⇒ Unit): Unit
-
def
testNames
: Set[String]
-
def
testsFor
(unit: Unit): Unit
-
def
toString
(): String
-
lazy val
var_decl
: Parser[VarDecl]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
lazy val
while_stmt
: Parser[WhileStmt]
-
val
whiteSpace
: Regex
-
def
withClue
(clue: Any)(fun: ⇒ Unit): Unit
-
def
withFixture
(test: NoArgTest): Unit
-
def
wrap
[T, U]
(p: ⇒ Parser[T], f: (T) ⇒ Either[U, String]): Parser[U]
-
lazy val
xtends
: Parser[Use]
Inherited from FunSuite
Inherited from Suite
Inherited from Serializable
Inherited from AbstractSuite
Inherited from Assertions
Inherited from ParserUtilities
Inherited from PackratParsers
Inherited from RegexParsers
Inherited from Parsers
Inherited from AnyRef
Inherited from Any