diff --git a/reactor/Test/src/program/MemConstraint.kt b/reactor/Test/src/program/MockConstraint.kt
similarity index 91%
rename from reactor/Test/src/program/MemConstraint.kt
rename to reactor/Test/src/program/MockConstraint.kt
index 010ad992..55f91604 100644
--- a/reactor/Test/src/program/MemConstraint.kt
+++ b/reactor/Test/src/program/MockConstraint.kt
@@ -12,7 +12,7 @@ import java.util.*
  * @author Fedor Isakov
  */
 
-data class MemConstraint(val symbol: ConstraintSymbol, val arguments: List<Any>) : Constraint {
+data class MockConstraint(val symbol: ConstraintSymbol, val arguments: List<Any>) : Constraint {
 
     constructor(symbol: ConstraintSymbol, vararg args: Any) : this(symbol, listOf(* args)) {}
 
diff --git a/reactor/Test/src/program/MemProgram.kt b/reactor/Test/src/program/MockProgram.kt
similarity index 89%
rename from reactor/Test/src/program/MemProgram.kt
rename to reactor/Test/src/program/MockProgram.kt
index 117b0d8c..22a011e5 100644
--- a/reactor/Test/src/program/MemProgram.kt
+++ b/reactor/Test/src/program/MockProgram.kt
@@ -5,24 +5,22 @@
 import jetbrains.mps.logic.reactor.evaluation.Queryable
 import jetbrains.mps.logic.reactor.evaluation.SessionSolver
 import jetbrains.mps.logic.reactor.program.*
-import program.MemConstraint
+import program.MockConstraint
 import java.util.*
 import java.util.Collections.*
 
-class MemProgramBuilder(val registry: ConstraintRegistry)  {
+class ProgramBuilder(val registry: ConstraintRegistry)  {
 
     private val rules = ArrayList<Rule>()
 
-    fun program(name: String): Program = MemProgram(name, ArrayList(rules), registry)
+    fun program(name: String): Program = MockProgram(name, ArrayList(rules), registry)
 
     fun addRule(rule: Rule) {
         registry.update(rule)
         rules.add(rule)
     }
 
-    fun constraint(symbol: ConstraintSymbol, vararg args: Any): Constraint = MemConstraint(symbol, listOf(* args))
-
-    fun predicate(symbol: PredicateSymbol, vararg args: Any?): Predicate = TODO()
+    fun constraint(symbol: ConstraintSymbol, vararg args: Any): Constraint = MockConstraint(symbol, listOf(* args))
 
 }
 
@@ -45,10 +43,10 @@ open class RuleBuilder(val tag: String) {
         if (alt || body.isEmpty()) body.add(ArrayList<AndItem>())
         body.last().addAll(andItem)
     }
-    fun toRule(): Rule = MemRule(tag, kept, replaced, guard, body)
+    fun toRule(): Rule = MockRule(tag, kept, replaced, guard, body)
 }
 
-class MemRule(
+class MockRule(
     val tag: String,
     val kept: Collection<Constraint>,
     val replaced: Collection<Constraint>,
@@ -74,7 +72,7 @@ class MemRule(
         else (kept + replaced).map { it as AndItem } + guard + body.flatten()
 }
 
-class MemProgram(val name: String, val myRules : List<Rule>, val registry: ConstraintRegistry) : Program() {
+class MockProgram(val name: String, val myRules : List<Rule>, val registry: ConstraintRegistry) : Program() {
 
     override fun name(): String = name
 
diff --git a/reactor/Test/src/solver/MemSessionSolver.kt b/reactor/Test/src/solver/MockSessionSolver.kt
similarity index 92%
rename from reactor/Test/src/solver/MemSessionSolver.kt
rename to reactor/Test/src/solver/MockSessionSolver.kt
index 16a1f140..4ad99260 100644
--- a/reactor/Test/src/solver/MemSessionSolver.kt
+++ b/reactor/Test/src/solver/MockSessionSolver.kt
@@ -11,7 +11,7 @@ import jetbrains.mps.logic.reactor.program.PredicateSymbol
  * @author Fedor Isakov
  */
 
-open class MemSessionSolver(val expressionSolver: Solver, val equalsSolver: Solver) : SessionSolver() {
+open class MockSessionSolver(val expressionSolver: Solver, val equalsSolver: Solver) : SessionSolver() {
 
     override fun solverClass(predicateSymbol: PredicateSymbol): Class<out Queryable> {
         return when (predicateSymbol) {
diff --git a/reactor/Test/test/RulesHelper.kt b/reactor/Test/test/RulesHelper.kt
index 709016b6..15443358 100644
--- a/reactor/Test/test/RulesHelper.kt
+++ b/reactor/Test/test/RulesHelper.kt
@@ -1,7 +1,7 @@
 import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence
 import jetbrains.mps.logic.reactor.logical.LogicalContext
 import jetbrains.mps.logic.reactor.program.*
-import program.MemConstraint
+import program.MockConstraint
 import TestConstraintOccurrence
 import jetbrains.mps.logic.reactor.core.StoreItem
 import solver.EqualsSolver
@@ -15,7 +15,7 @@ import java.util.*
 class Builder(val env: Environment, val rules: List<Rule>) {
 }
 
-class Environment(val programBuilder: MemProgramBuilder? = null) {
+class Environment(val programBuilder: ProgramBuilder? = null) {
     val equalsSolver = EqualsSolver()
     val expressionSolver = ExpressionSolver()
 }
@@ -24,7 +24,7 @@ fun program(vararg ruleBuilders : Environment.() -> Rule): Builder {
     return builder(Environment(), ruleBuilders)
 }
 
-fun program(pb: MemProgramBuilder, vararg ruleBuilders : Environment.() -> Rule): Builder {
+fun program(pb: ProgramBuilder, vararg ruleBuilders : Environment.() -> Rule): Builder {
     return builder(Environment(pb), ruleBuilders)
 }
 
@@ -98,7 +98,7 @@ class ConjBuilder {
     fun createConstraint(args: Array<out Any>, id: String): Constraint {
         return env.programBuilder ?.
             constraint(ConstraintSymbol(id, args.size), * args)     ?:
-            MemConstraint(ConstraintSymbol(id, args.size), * args)
+            MockConstraint(ConstraintSymbol(id, args.size), * args)
     }
 
 
@@ -148,7 +148,7 @@ data class TestConstraintOccurrence(val constraint: Constraint, val arguments: L
     }
 
     constructor(id: String, vararg args: Any) :
-        this(MemConstraint(ConstraintSymbol.symbol(id, args.size)), listOf(* args), random.nextInt()) {}
+        this(MockConstraint(ConstraintSymbol.symbol(id, args.size)), listOf(* args), random.nextInt()) {}
 
     override fun constraint(): Constraint = constraint
 
diff --git a/reactor/Test/test/TestController.kt b/reactor/Test/test/TestController.kt
index d793ba40..aab9d7c6 100644
--- a/reactor/Test/test/TestController.kt
+++ b/reactor/Test/test/TestController.kt
@@ -12,7 +12,7 @@ import jetbrains.mps.logic.reactor.program.Program
 import org.junit.*
 import org.junit.Assert.*
 import solver.EqualsSolver
-import solver.MemSessionSolver
+import solver.MockSessionSolver
 
 /**
  * @author Fedor Isakov
@@ -56,7 +56,7 @@ class TestController {
     }
 
     private fun sessionSolver(expressionSolver: ExpressionSolver, equalsSolver: EqualsSolver): SessionSolver =
-        MemSessionSolver(expressionSolver, equalsSolver).apply {
+        MockSessionSolver(expressionSolver, equalsSolver).apply {
             init(PredicateSymbol("equals", 2), JavaPredicateSymbol.EXPRESSION0, JavaPredicateSymbol.EXPRESSION1, JavaPredicateSymbol.EXPRESSION2, JavaPredicateSymbol.EXPRESSION3) }
 
     private fun Builder.handler(vararg occurrences: ConstraintOccurrence): Controller {
diff --git a/reactor/Test/test/TestProgram.kt b/reactor/Test/test/TestProgram.kt
index fe05eefb..34ca15e3 100644
--- a/reactor/Test/test/TestProgram.kt
+++ b/reactor/Test/test/TestProgram.kt
@@ -1,13 +1,13 @@
 import jetbrains.mps.logic.reactor.core.MemEvaluationSession
 import jetbrains.mps.logic.reactor.evaluation.EvaluationSession
 import jetbrains.mps.logic.reactor.logical.Logical
-import solver.MemSessionSolver
+import solver.MockSessionSolver
 import jetbrains.mps.logic.reactor.program.ConstraintSymbol
 import jetbrains.mps.logic.reactor.program.JavaPredicateSymbol
 import jetbrains.mps.logic.reactor.program.PredicateSymbol
 import org.junit.*
 import org.junit.Assert.*
-import program.MemConstraint
+import program.MockConstraint
 import solver.eq
 import solver.is_eq
 
@@ -27,12 +27,12 @@ class TestProgram {
     }
 
     private fun Builder.session(name: String): EvaluationSession {
-        val sessionSolver = MemSessionSolver(env.expressionSolver, env.equalsSolver)
-        val programBuilder = MemProgramBuilder(ConstraintRegistry(sessionSolver))
+        val sessionSolver = MockSessionSolver(env.expressionSolver, env.equalsSolver)
+        val programBuilder = ProgramBuilder(ConstraintRegistry(sessionSolver))
         rules.forEach { r -> programBuilder.addRule(r) }
         return EvaluationSession.newSession(programBuilder.program(name)).
             withPredicates(PredicateSymbol("equals", 2), JavaPredicateSymbol.EXPRESSION0, JavaPredicateSymbol.EXPRESSION1, JavaPredicateSymbol.EXPRESSION2, JavaPredicateSymbol.EXPRESSION3).
-            withParam("main", MemConstraint(ConstraintSymbol("main", 0))).start(sessionSolver)
+            withParam("main", MockConstraint(ConstraintSymbol("main", 0))).start(sessionSolver)
     }
 
     @Test
diff --git a/reactor/Test/test/TestProgramBuilder.kt b/reactor/Test/test/TestProgramBuilder.kt
index 64d1ecef..cd68e8f9 100644
--- a/reactor/Test/test/TestProgramBuilder.kt
+++ b/reactor/Test/test/TestProgramBuilder.kt
@@ -1,7 +1,7 @@
 import jetbrains.mps.logic.reactor.evaluation.PredicateInvocation
 import jetbrains.mps.logic.reactor.evaluation.Queryable
 import jetbrains.mps.logic.reactor.evaluation.Solver
-import solver.MemSessionSolver
+import solver.MockSessionSolver
 import jetbrains.mps.logic.reactor.program.*
 import org.junit.AfterClass
 import org.junit.Assert.*
@@ -23,15 +23,15 @@ class TestProgramBuilder {
         override fun tell(invocation: PredicateInvocation?) = TODO()
     }
 
-    val sessionSolver = MemSessionSolver(dummySolver, dummySolver)
+    val sessionSolver = MockSessionSolver(dummySolver, dummySolver)
 
     @Before fun beforeTest() {
-        programBuilder = MemProgramBuilder(ConstraintRegistry(sessionSolver))
+        programBuilder = ProgramBuilder(ConstraintRegistry(sessionSolver))
     }
 
-    lateinit var programBuilder: MemProgramBuilder
+    lateinit var programBuilder: ProgramBuilder
 
-    private fun MemProgramBuilder.addRules(rules: List<Rule>) {
+    private fun ProgramBuilder.addRules(rules: List<Rule>) {
         rules.forEach { r -> addRule(r) }
     }