MemoRewriterTests

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object Equal extends Expecting with Product with Serializable

object FocusTest extends Tag

A ScalaTest tag that enables us to focus attention on particular tests rather than running all of them each time.

object NotSame extends Expecting with Product with Serializable

object Same extends Expecting with Product with Serializable

def after(fun: ⇒ Any): Unit

implicit def arbAsgn: Arbitrary[Asgn]

implicit def arbExp: Arbitrary[Exp]

implicit def arbNum: Arbitrary[Num]

implicit def arbSeqn: Arbitrary[Seqn]

implicit def arbStmt: Arbitrary[Stmt]

implicit def arbWhile: Arbitrary[While]

final 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

Assert that a message was produced at a given position.

val atob: Strategy

def before(fun: ⇒ Any): Unit

def check(p: Prop, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig): Unit

def check(p: Prop, prms: Params): Unit

def check[A1, A2, A3, A4, A5, A6, P](f: (A1, A2, A3, A4, A5, A6) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty, a6: Arbitrary[A6], s6: Shrink[A6], pp6: (A6) ⇒ Pretty): Unit

def check[A1, A2, A3, A4, A5, P](f: (A1, A2, A3, A4, A5) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty, a5: Arbitrary[A5], s5: Shrink[A5], pp5: (A5) ⇒ Pretty): Unit

def check[A1, A2, A3, A4, P](f: (A1, A2, A3, A4) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty, a4: Arbitrary[A4], s4: Shrink[A4], pp4: (A4) ⇒ Pretty): Unit

def check[A1, A2, A3, P](f: (A1, A2, A3) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty, a3: Arbitrary[A3], s3: Shrink[A3], pp3: (A3) ⇒ Pretty): Unit

def check[A1, A2, P](f: (A1, A2) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty, a2: Arbitrary[A2], s2: Shrink[A2], pp2: (A2) ⇒ Pretty): Unit

def check[A1, P](f: (A1) ⇒ P, configParams: PropertyCheckConfigParam*)(implicit config: PropertyCheckConfig, p: (P) ⇒ Prop, a1: Arbitrary[A1], s1: Shrink[A1], pp1: (A1) ⇒ Pretty): Unit

def clone(): AnyRef

implicit def convertToEqualizer(left: Any): Equalizer

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def execute(testName: String, configMap: Map[String, Any], color: Boolean, durations: Boolean, shortstacks: Boolean, fullstacks: Boolean, stats: Boolean): Unit

def expectResult(expected: Any)(actual: Any): Unit

def expectResult(expected: Any, clue: Any)(actual: Any): Unit

def expectedTestCount(filter: Filter): Int

def expectnotsame(expected: Any)(actual: Any): Unit

Analogous to ScalaTest's expect but it uses same to compare the two values instead of equality.

def expectsame(expected: Any)(actual: Any): Unit

Analogous to ScalaTest's expect but it uses same to compare the two values instead of equality.

def fail(cause: Throwable): Nothing

def fail(message: String, cause: Throwable): Nothing

def fail(message: String): Nothing

def fail(): Nothing

def failExpectedTest[T](expected: T, found: T, description: String = ""): Unit

Fail a test with a message about finding something and expecting something else.

def finalize(): Unit

def genAdd(sz: Int): Gen[Add]

def genAsgn(sz: Int): Gen[Asgn]

def genDiv(sz: Int): Gen[Div]

val genDouble: Gen[Num]

def genExp(sz: Int): Gen[Exp]

val genIdn: Gen[String]

val genInteger: Gen[Num]

def genInternalExp(sz: Int): Gen[Exp]

def genInternalStmt(sz: Int): Gen[Stmt]

val genLeafExp: Gen[Exp with Serializable]

val genLeafStmt: Gen[Null]

def genMul(sz: Int): Gen[Mul]

def genNeg(sz: Int): Gen[Neg]

val genNum: Gen[Num]

def genSeqn(sz: Int): Gen[Seqn]

def genStmt(sz: Int): Gen[Stmt]

def genSub(sz: Int): Gen[Sub]

val genVar: Gen[Var]

def genWhile(sz: Int): Gen[While]

implicit val generatorDrivenConfig: PropertyCheckConfig

final def getClass(): Class[_]

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

final def isInstanceOf[T0]: Boolean

def maxDiscarded(value: Int): MaxDiscarded

def maxSize(value: Int): MaxSize

def minSize(value: Int): MinSize

def minSuccessful(value: Int): MinSuccessful

val myrule1: Strategy

val mystrategy1: Strategy

final def ne(arg0: AnyRef): Boolean

def nestedSuites: List[Suite]

final def notify(): Unit

final def notifyAll(): Unit

def pending: PendingNothing

def pendingUntilFixed(f: ⇒ Unit): Unit

val rewriter: MemoRewriter.type

The rewriter which is being tested.

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

Compare two values.

final val styleName: String

def suiteName: String

final 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 testSharingRewrite(direction: String, strat: Strategy): Unit

Generate tests that ensure that if a node is rewritten more than once in a traversal by strat the results at each stage will be shared in the overall result.

def testsFor(unit: Unit): Unit

def toString(): String

def travtest(basemsg: String, testmsg: String, eval: Option[Any], result: Option[Any], expecting: Expecting = Equal): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withClue[T](clue: Any)(fun: ⇒ T): T

def withFixture(test: NoArgTest): Unit

def workers(value: Int): Workers

def expect(expected: Any)(actual: Any): Unit

def expect(expected: Any, clue: Any)(actual: Any): Unit