natas_hw
/
mps-coderules
mirror of https://github.com/JetBrains/mps-coderules
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

New naming convention for test helper classes (prefix Mock-).

This commit is contained in:
Fedor Isakov 2016-12-22 15:56:23 +01:00
parent e80818607c
commit 49a6ee0bd0
7 changed files with 26 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
reactor/Test/src/program/MemConstraint.kt → reactor/Test/src/program/MockConstraint.kt
View File

@ -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)) {}

16
reactor/Test/src/program/MemProgram.kt → reactor/Test/src/program/MockProgram.kt
View File

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

2
reactor/Test/src/solver/MemSessionSolver.kt → reactor/Test/src/solver/MockSessionSolver.kt
View File

@ -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) {

10
reactor/Test/test/RulesHelper.kt
View File

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

4
reactor/Test/test/TestController.kt
View File

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

10
reactor/Test/test/TestProgram.kt
View File

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

10
reactor/Test/test/TestProgramBuilder.kt
View File

@ -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) }
}