From 6c57f5fe0a5e7eb8fb3e2480b13266df6a8ecd43 Mon Sep 17 00:00:00 2001 From: daemontus Date: Sat, 19 Sep 2015 12:26:14 +0200 Subject: [PATCH] Migrate to Kotlin M13 --- build.gradle | 2 +- src/main/kotlin/cz/muni/fi/ctl/Parser.kt | 23 +++--- .../kotlin/cz/muni/fi/ctl/FormulasTest.kt | 28 +++---- .../kotlin/cz/muni/fi/ctl/IntegrationTest.kt | 12 +-- .../kotlin/cz/muni/fi/ctl/NormalizerTest.kt | 38 +++++----- .../kotlin/cz/muni/fi/ctl/OptimizerTest.kt | 20 ++--- .../kotlin/cz/muni/fi/ctl/ParserBasicTest.kt | 12 +-- .../cz/muni/fi/ctl/ParserComplexTest.kt | 32 ++++---- .../cz/muni/fi/ctl/ParserIncludeTest.kt | 44 +++++------ .../cz/muni/fi/ctl/ParserReferencesTest.kt | 74 +++++++++---------- 10 files changed, 142 insertions(+), 143 deletions(-) diff --git a/build.gradle b/build.gradle index af3a04e..a1686fd 100644 --- a/build.gradle +++ b/build.gradle @@ -1,6 +1,6 @@ //include antlr plugin buildscript { - ext.kotlin_version = '0.12.1230' + ext.kotlin_version = '0.13.1513' repositories { maven { name 'JFrog OSS snapshot repo' diff --git a/src/main/kotlin/cz/muni/fi/ctl/Parser.kt b/src/main/kotlin/cz/muni/fi/ctl/Parser.kt index 25190ad..c5e4720 100644 --- a/src/main/kotlin/cz/muni/fi/ctl/Parser.kt +++ b/src/main/kotlin/cz/muni/fi/ctl/Parser.kt @@ -9,10 +9,7 @@ import org.antlr.v4.runtime.tree.ParseTree import org.antlr.v4.runtime.tree.ParseTreeProperty import org.antlr.v4.runtime.tree.ParseTreeWalker import java.io.File -import java.util.ArrayList -import java.util.HashMap -import java.util.HashSet -import java.util.Stack +import java.util.* /** * Workflow: @@ -49,7 +46,7 @@ public class Parser { throw IllegalStateException("Cyclic reference: ${f.name}") else -> { replaced.push(f.name) - val result = references[f.name].treeMap(::replace) + val result = references[f.name]!!.treeMap(::replace) replaced.pop() result } @@ -88,7 +85,7 @@ class FileParser { processStream(ANTLRInputStream(input.toCharArray(), input.length()), "input string") private fun processFile(input: File): FileContext = - input.inputStream().use { processStream(ANTLRInputStream(it), input.getAbsolutePath()) } + input.inputStream().use { processStream(ANTLRInputStream(it), input.absolutePath) } private fun processStream(input: ANTLRInputStream, location: String): FileContext { val root = CTLParser(CommonTokenStream(CTLLexer(input))).root() @@ -137,22 +134,22 @@ class FileContext(val location: String) : CTLBaseListener() { fun toParseContext() = ParserContext(assignments) override fun exitInclude(ctx: CTLParser.IncludeContext) { - val string = ctx.STRING().getText()!! + val string = ctx.STRING().text!! includes.add(File(string.substring(1, string.length() - 1))) //remove quotes } override fun exitAssign(ctx: CTLParser.AssignContext) { assignments.add(Assignment( - ctx.VAR_NAME().getText()!!, + ctx.VAR_NAME().text!!, formulas[ctx.formula()]!!, - location+":"+ctx.start.getLine() + location+":"+ctx.start.line )) } /** ------ Formula Parsing ------ **/ override fun exitId(ctx: CTLParser.IdContext) { - formulas[ctx] = Reference(ctx.getText()!!) + formulas[ctx] = Reference(ctx.text!!) } override fun exitBool(ctx: CTLParser.BoolContext) { @@ -161,7 +158,7 @@ class FileContext(val location: String) : CTLBaseListener() { override fun exitDirection(ctx: CTLParser.DirectionContext) { formulas[ctx] = DirectionProposition( - variable = ctx.VAR_NAME().getText()!!, + variable = ctx.VAR_NAME().text!!, direction = if (ctx.IN() != null) Direction.IN else Direction.OUT, facet = if (ctx.PLUS() != null) Facet.POSITIVE else Facet.NEGATIVE ) @@ -169,9 +166,9 @@ class FileContext(val location: String) : CTLBaseListener() { override fun exitProposition(ctx: CTLParser.PropositionContext) { formulas[ctx] = FloatProposition( - variable = ctx.VAR_NAME().getText()!!, + variable = ctx.VAR_NAME().text!!, floatOp = ctx.floatOp().toOperator(), - value = ctx.FLOAT_VAL().getText().toDouble() + value = ctx.FLOAT_VAL().text.toDouble() ) } diff --git a/src/test/kotlin/cz/muni/fi/ctl/FormulasTest.kt b/src/test/kotlin/cz/muni/fi/ctl/FormulasTest.kt index 9767bf4..a1ea973 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/FormulasTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/FormulasTest.kt @@ -2,7 +2,7 @@ package cz.muni.fi.ctl import org.junit.Test import kotlin.test.assertEquals -import kotlin.test.failsWith +import kotlin.test.assertFailsWith class MapTest { @@ -13,13 +13,13 @@ class MapTest { ) ) - Test fun treeMapId() { + @Test fun treeMapId() { assertEquals(formula, formula.treeMap { it }) } - Test fun treeMapPropositions() { + @Test fun treeMapPropositions() { formula.treeMap { if (it.operator.cardinality == 0) throw IllegalStateException("Executing tree map on a leaf") @@ -27,7 +27,7 @@ class MapTest { } } - Test fun treeMapComplex() { + @Test fun treeMapComplex() { fun transform(f: Formula): Formula = when(f.operator) { Op.EXISTS_NEXT -> FormulaImpl(Op.ALL_NEXT, f.subFormulas.map(::transform)) @@ -50,40 +50,40 @@ class MapTest { class Misc { - Test fun booleanToString() { + @Test fun booleanToString() { assertEquals("True", True.toString()) assertEquals("False", False.toString()) } - Test fun formulaToString() { + @Test fun formulaToString() { assertEquals("(True && EX (False EU True))", (True and EX(False EU True)).toString()) } - Test fun floatToString() { + @Test fun floatToString() { assertEquals("prop > 5.3", FloatProposition("prop", FloatOp.GT, 5.3).toString()) } - Test fun directionToString() { + @Test fun directionToString() { assertEquals("prop:in+", DirectionProposition("prop", Direction.IN, Facet.POSITIVE).toString()) } - Test fun emptyFormula() { + @Test fun emptyFormula() { assertEquals("null([])",FormulaImpl().toString()) } - Test fun notEnoughFormulas() { - failsWith(javaClass()) { + @Test fun notEnoughFormulas() { + assertFailsWith(IllegalArgumentException::class) { FormulaImpl(Op.ALL_UNTIL, True) } } - Test fun tooManyFormulas() { - failsWith(javaClass()) { + @Test fun tooManyFormulas() { + assertFailsWith(IllegalArgumentException::class) { FormulaImpl(Op.ALL_UNTIL, True, False, Atom()) } } - Test fun get() { + @Test fun get() { val float = FloatProposition("val", FloatOp.GT, 34.12) assertEquals("val", float.variable) assertEquals(FloatOp.GT, float.floatOp) diff --git a/src/test/kotlin/cz/muni/fi/ctl/IntegrationTest.kt b/src/test/kotlin/cz/muni/fi/ctl/IntegrationTest.kt index 46612bd..ca318e1 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/IntegrationTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/IntegrationTest.kt @@ -9,7 +9,7 @@ import kotlin.test.assertEquals */ class Integration { - Test fun test() { + @Test fun test() { val f1 = File.createTempFile("file", ".ctl") @@ -23,7 +23,7 @@ class Integration { } val formulas = parser.parse( - "#include \"${ f1.getAbsolutePath() }\" \n" + + "#include \"${ f1.absolutePath }\" \n" + """ a = True && p1:out+ f = EF True && EG pop || AX a @@ -39,10 +39,10 @@ class Integration { val f = (EF(True) and EG(pop)) or AX(a) assertEquals(4, formulas.size()) - assertEquals(a, formulas.get("a")) - assertEquals(c, formulas.get("c")) - assertEquals(pop, formulas.get("pop")) - assertEquals(f, formulas.get("f")) + assertEquals(a, formulas["a"]) + assertEquals(c, formulas["c"]) + assertEquals(pop, formulas["pop"]) + assertEquals(f, formulas["f"]) val normalized = normalizer.normalize(f) diff --git a/src/test/kotlin/cz/muni/fi/ctl/NormalizerTest.kt b/src/test/kotlin/cz/muni/fi/ctl/NormalizerTest.kt index fb766de..bfddc0c 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/NormalizerTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/NormalizerTest.kt @@ -12,7 +12,7 @@ class UntilNormalFormTest { val normalizer = Normalizer() - Test fun complexTest() { + @Test fun complexTest() { val f1 = FloatProposition("var1", FloatOp.NEQ, 14.3) val f2 = FloatProposition("var2", FloatOp.LT, -15.3) @@ -29,7 +29,7 @@ class UntilNormalFormTest { ) } - Test fun nestingNoPropositions() { + @Test fun nestingNoPropositions() { val prop = EF( p1 implies AX( EG(p2) EU AG(p1))) assertEquals( True EU (not(p1) or not( EX( not( (not( True AU not(p2))) EU (not( True EU not(p1))) )))), @@ -37,103 +37,103 @@ class UntilNormalFormTest { ) } - Test fun nestingPreserve() { + @Test fun nestingPreserve() { val prop = (p1 and EX(not(p2))) EU ( not(p3) AU (p4 or p2)) assertEquals(prop, normalizer.normalize(prop)) } //trivial cases - Test fun equivChange() { + @Test fun equivChange() { val prop = p1 equal p2 val norm = normalizer.normalize(prop) assertEquals( (p1 and p2) or (not(p1) and not(p2)), norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun implChange() { + @Test fun implChange() { val prop = p1 implies p2 val norm = normalizer.normalize(prop) assertEquals(not(p1) or p2, norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun agChange() { + @Test fun agChange() { val prop = AG(p1) val norm = normalizer.normalize(prop) assertEquals(not( True EU not(p1) ), norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun egChange() { + @Test fun egChange() { val prop = EG(p1) val norm = normalizer.normalize(prop) assertEquals(not( True AU not(p1) ), norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun afChange() { + @Test fun afChange() { val prop = AF(p1) val norm = normalizer.normalize(prop) assertEquals(True AU p1, norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun efChange() { + @Test fun efChange() { val prop = EF(p1) val norm = normalizer.normalize(prop) assertEquals(True EU p1, norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun axChange() { + @Test fun axChange() { val prop = AX(p1) val norm = normalizer.normalize(prop) assertEquals(not( EX( not(p1) ) ), norm) assertEquals(norm, normalizer.normalize(norm)) } - Test fun auPreserve() { + @Test fun auPreserve() { val prop = p1 AU p2 assertEquals(prop, normalizer.normalize(prop)) } - Test fun euPreserve() { + @Test fun euPreserve() { val prop = p1 EU p2 assertEquals(prop, normalizer.normalize(prop)) } - Test fun orPreserve() { + @Test fun orPreserve() { val prop = p1 or p2 assertEquals(prop, normalizer.normalize(prop)) } - Test fun andPreserve() { + @Test fun andPreserve() { val prop = p1 and p2 assertEquals(prop, normalizer.normalize(prop)) } - Test fun negPreserve() { + @Test fun negPreserve() { val prop = not(p1) assertEquals(prop, normalizer.normalize(prop)) } - Test fun exPreserve() { + @Test fun exPreserve() { val prop = EX(p1) assertEquals(prop, normalizer.normalize(prop)) } - Test fun floatPreserve() { + @Test fun floatPreserve() { val prop = FloatProposition("val", FloatOp.GT_EQ, 32.2) assertEquals(prop, normalizer.normalize(prop)) } - Test fun booleanPreserve() { + @Test fun booleanPreserve() { assertEquals(True, normalizer.normalize(True)) assertEquals(False, normalizer.normalize(False)) } - Test fun directionPreserve() { + @Test fun directionPreserve() { val prop = DirectionProposition("var", Direction.IN, Facet.POSITIVE) assertEquals(prop, normalizer.normalize(prop)) } diff --git a/src/test/kotlin/cz/muni/fi/ctl/OptimizerTest.kt b/src/test/kotlin/cz/muni/fi/ctl/OptimizerTest.kt index 3eda50e..2bbd484 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/OptimizerTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/OptimizerTest.kt @@ -10,7 +10,7 @@ class OptimizerTest { val optimizer = Optimizer() - Test fun complexTest() { + @Test fun complexTest() { val f1 = FloatProposition("var2", FloatOp.LT_EQ, -15.3) val nf1 = FloatProposition("var2", FloatOp.GT, -15.3) val d1 = DirectionProposition("var1", Direction.IN, Facet.NEGATIVE) @@ -22,15 +22,15 @@ class OptimizerTest { assertEquals(optimized, optimizer.optimize(optimized)) } - Test fun orNegation() { + @Test fun orNegation() { assertEquals(not(p1 and p2), optimizer.optimize(not(p1) or not(p2))) } - Test fun andNegation() { + @Test fun andNegation() { assertEquals(not(p1 or p2), optimizer.optimize(not(p1) and not(p2))) } - Test fun floatNegation() { + @Test fun floatNegation() { assertEquals( FloatProposition("val", FloatOp.NEQ, 13.2), optimizer.optimize( @@ -45,32 +45,32 @@ class OptimizerTest { ) } - Test fun doubleNegation() { + @Test fun doubleNegation() { assertEquals(p1, optimizer.optimize(not(not(p1)))) assertEquals(not(p2), optimizer.optimize(not(not(not(p2))))) } - Test fun booleanReduction() { + @Test fun booleanReduction() { val prop = EX( not(False) and ( (True or False) EU (False AU True) )) assertEquals(True, optimizer.optimize(prop)) } - Test fun preserveUnsupported() { + @Test fun preserveUnsupported() { val prop = AX(EG(p1 implies p2)) assertEquals(prop, optimizer.optimize(prop)) } - Test fun floatPreserve() { + @Test fun floatPreserve() { val prop = FloatProposition("val", FloatOp.GT_EQ, 32.2) assertEquals(prop, optimizer.optimize(prop)) } - Test fun booleanPreserve() { + @Test fun booleanPreserve() { assertEquals(True, optimizer.optimize(True)) assertEquals(False, optimizer.optimize(False)) } - Test fun directionPreserve() { + @Test fun directionPreserve() { val prop = DirectionProposition("var", Direction.IN, Facet.POSITIVE) assertEquals(prop, optimizer.optimize(prop)) } diff --git a/src/test/kotlin/cz/muni/fi/ctl/ParserBasicTest.kt b/src/test/kotlin/cz/muni/fi/ctl/ParserBasicTest.kt index d22251b..8dcb29b 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/ParserBasicTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/ParserBasicTest.kt @@ -7,14 +7,14 @@ class Basic { val parser = Parser() - Test fun parenthesis() { + @Test fun parenthesis() { assertEquals( True, parser.formula("(True)") ) } - Test fun binaryOps() { + @Test fun binaryOps() { assertEquals( True EU False, parser.formula("True EU False") @@ -41,7 +41,7 @@ class Basic { ) } - Test fun unaryOps() { + @Test fun unaryOps() { assertEquals( not(True), parser.formula("!True") @@ -72,7 +72,7 @@ class Basic { ) } - Test fun floats() { + @Test fun floats() { assertEquals( FloatProposition("var", FloatOp.EQ, 0.0), parser.formula("var == 0") @@ -103,7 +103,7 @@ class Basic { ) } - Test fun directions() { + @Test fun directions() { assertEquals( DirectionProposition("var", Direction.IN, Facet.POSITIVE), parser.formula("var:in+") @@ -122,7 +122,7 @@ class Basic { ) } - Test fun booleans() { + @Test fun booleans() { assertEquals(True, parser.formula("true")) assertEquals(True, parser.formula("True")) assertEquals(True, parser.formula("tt")) diff --git a/src/test/kotlin/cz/muni/fi/ctl/ParserComplexTest.kt b/src/test/kotlin/cz/muni/fi/ctl/ParserComplexTest.kt index fa5caf5..45be4c4 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/ParserComplexTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/ParserComplexTest.kt @@ -13,7 +13,7 @@ class Complex { val p2 = DirectionProposition("p2", Direction.IN, Facet.NEGATIVE) val p3 = FloatProposition("p3", FloatOp.LT, -3.14) - Test fun complexFiles() { + @Test fun complexFiles() { val f1 = File.createTempFile("file", ".ctl") val f2 = File.createTempFile("file2", ".ctl") @@ -24,14 +24,14 @@ class Complex { } f2.bufferedWriter().use { - it.write("#include \"${ f1.getAbsolutePath() }\" \n") + it.write("#include \"${ f1.absolutePath }\" \n") it.write("b = EX c <=> True \n") it.write("d = e => e") } f3.bufferedWriter().use { it.write("a = ! p1 == 4 \n") - it.write("#include \"${ f2.getAbsolutePath() }\" \n") + it.write("#include \"${ f2.absolutePath }\" \n") it.write("e = True && c || c && False") } @@ -44,11 +44,11 @@ class Complex { val d = e implies e assertEquals(5, result.size()) - assertEquals(a, result.get("a")) - assertEquals(b, result.get("b")) - assertEquals(c, result.get("c")) - assertEquals(d, result.get("d")) - assertEquals(e, result.get("e")) + assertEquals(a, result["a"]) + assertEquals(b, result["b"]) + assertEquals(c, result["c"]) + assertEquals(d, result["d"]) + assertEquals(e, result["e"]) f1.delete() f2.delete() @@ -56,7 +56,7 @@ class Complex { } - Test fun complexString() { + @Test fun complexString() { val result = parser.parse(""" b = EX p3 < -3.14 EU a @@ -73,15 +73,15 @@ class Complex { val e = (c and True) or (False and b) assertEquals(5, result.size()) - assertEquals(a, result.get("a")) - assertEquals(b, result.get("b")) - assertEquals(c, result.get("c")) - assertEquals(d, result.get("d")) - assertEquals(e, result.get("e")) + assertEquals(a, result["a"]) + assertEquals(b, result["b"]) + assertEquals(c, result["c"]) + assertEquals(d, result["d"]) + assertEquals(e, result["e"]) } - Test fun operatorAssociativity() { + @Test fun operatorAssociativity() { //These binary operators are by convention right-associative //Other binary operators, such as &&, ||, <=> are associative, //so it doesn't matter if we resolve them left to right or right to left @@ -99,7 +99,7 @@ class Complex { ) } - Test fun operatorPriority() { + @Test fun operatorPriority() { //we do not test every combination, since priority should be transitive assertEquals( not(False) and not(True), diff --git a/src/test/kotlin/cz/muni/fi/ctl/ParserIncludeTest.kt b/src/test/kotlin/cz/muni/fi/ctl/ParserIncludeTest.kt index 463d119..2ae66c6 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/ParserIncludeTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/ParserIncludeTest.kt @@ -4,46 +4,48 @@ import org.junit.Test import java.io.File import java.io.FileNotFoundException import kotlin.test.assertEquals +import kotlin.test.assertFailsWith class Includes { val parser = Parser() - Test(expected = FileNotFoundException::class) - fun invalidInclude() { - parser.parse("#include \"bogus.foo\" ") + @Test fun invalidInclude() { + assertFailsWith(FileNotFoundException::class) { + parser.parse("#include \"bogus.foo\" ") + } } - Test fun duplicateInclude() { + @Test fun duplicateInclude() { val i1 = File.createTempFile("include1", ".ctl") val i2 = File.createTempFile("include2", ".ctl") i1.bufferedWriter().use { it.write("val = True \n") - it.write("#include \"${ i1.getAbsolutePath() }\"") + it.write("#include \"${ i1.absolutePath }\"") } i2.bufferedWriter().use { - it.write("#include \"${ i1.getAbsolutePath() }\" \n") - it.write("#include \"${ i2.getAbsolutePath() }\" \n") + it.write("#include \"${ i1.absolutePath }\" \n") + it.write("#include \"${ i2.absolutePath }\" \n") it.write("val2 = False") } val result = parser.parse( - "#include \"${ i2.getAbsolutePath() }\" \n" + - "#include \"${ i1.getAbsolutePath() }\" " + "#include \"${ i2.absolutePath }\" \n" + + "#include \"${ i1.absolutePath }\" " ) assertEquals(2, result.size()) - assertEquals(True, result.get("val")) - assertEquals(False, result.get("val2")) + assertEquals(True, result["val"]) + assertEquals(False, result["val2"]) i1.delete() i2.delete() } - Test fun transitiveInclude() { + @Test fun transitiveInclude() { val i1 = File.createTempFile("include1", ".ctl") val i2 = File.createTempFile("include2", ".ctl") @@ -52,20 +54,20 @@ class Includes { it.write("val = True") } i2.bufferedWriter().use { - it.write("#include \"${ i1.getAbsolutePath() }\"") + it.write("#include \"${ i1.absolutePath }\"") } - val result = parser.parse("#include \"${ i2.getAbsolutePath() }\"") + val result = parser.parse("#include \"${ i2.absolutePath }\"") assertEquals(1, result.size()) - assertEquals(True, result.get("val")) + assertEquals(True, result["val"]) i1.delete() i2.delete() } - Test fun simpleIncludeFromFile() { + @Test fun simpleIncludeFromFile() { val include = File.createTempFile("simpleInclude", ".ctl") @@ -75,19 +77,19 @@ class Includes { val file = File.createTempFile("simpleFile", ".ctl") file.bufferedWriter().use { - it.write("#include \"${include.getAbsolutePath()}\"") + it.write("#include \"${ include.absolutePath }\"") } val result = parser.parse(file) assertEquals(1, result.size()) - assertEquals(True, result.get("val")) + assertEquals(True, result["val"]) file.delete() include.delete() } - Test fun simpleIncludeFromString() { + @Test fun simpleIncludeFromString() { val file = File.createTempFile("simpleInclude", ".ctl") @@ -96,11 +98,11 @@ class Includes { } val result = parser.parse( - "#include \"${ file.getAbsolutePath() }\"" + "#include \"${ file.absolutePath }\"" ) assertEquals(1, result.size()) - assertEquals(True, result.get("val")) + assertEquals(True, result["val"]) file.delete() } diff --git a/src/test/kotlin/cz/muni/fi/ctl/ParserReferencesTest.kt b/src/test/kotlin/cz/muni/fi/ctl/ParserReferencesTest.kt index a959b4a..cc0f71f 100644 --- a/src/test/kotlin/cz/muni/fi/ctl/ParserReferencesTest.kt +++ b/src/test/kotlin/cz/muni/fi/ctl/ParserReferencesTest.kt @@ -3,20 +3,20 @@ package cz.muni.fi.ctl import org.junit.Test import java.io.File import kotlin.test.assertEquals -import kotlin.test.failsWith +import kotlin.test.assertFailsWith class References { val parser = Parser() - Test fun cyclicReferenceThroughFiles() { + @Test fun cyclicReferenceThroughFiles() { val file = File.createTempFile("file", ".ctx") file.bufferedWriter().use { it.write("k = m") } - failsWith(javaClass()) { + assertFailsWith(IllegalStateException::class) { parser.parse(""" m = !k """) @@ -24,8 +24,8 @@ class References { file.delete() } - Test fun transitiveCyclicReference() { - failsWith(javaClass()) { + @Test fun transitiveCyclicReference() { + assertFailsWith(IllegalStateException::class) { parser.parse(""" k = EX l l = AX m @@ -34,19 +34,19 @@ class References { } } - Test fun simpleCyclicReference() { - failsWith(javaClass()) { + @Test fun simpleCyclicReference() { + assertFailsWith(IllegalStateException::class) { parser.parse("k = !k") } } - Test fun undefinedReference() { - failsWith(javaClass()) { + @Test fun undefinedReference() { + assertFailsWith(IllegalStateException::class) { parser.parse("k = EF m") } } - Test fun declarationOrderIndependence() { + @Test fun declarationOrderIndependence() { val result = parser.parse(""" k = ! m @@ -54,12 +54,12 @@ class References { """) assertEquals(2, result.size()) - assertEquals(not(True), result.get("k")) - assertEquals(True, result.get("m")) + assertEquals(not(True), result["k"]) + assertEquals(True, result["m"]) } - Test fun duplicateDeclarationInFiles() { + @Test fun duplicateDeclarationInFiles() { val i1 = File.createTempFile("include1", ".ctl") @@ -67,9 +67,9 @@ class References { it.write("k = True") } - failsWith(javaClass()) { + assertFailsWith(IllegalStateException::class) { parser.parse( - "#include \"${ i1.getAbsolutePath() }\" \n" + + "#include \"${ i1.absolutePath }\" \n" + "k = False" ) } @@ -77,8 +77,8 @@ class References { i1.delete() } - Test fun duplicateDeclarationInString() { - failsWith(javaClass()) { + @Test fun duplicateDeclarationInString() { + assertFailsWith(IllegalStateException::class) { parser.parse(""" k = True l = False @@ -87,7 +87,7 @@ class References { } } - Test fun transitiveResolveInFiles() { + @Test fun transitiveResolveInFiles() { val i1 = File.createTempFile("include1", ".ctl") val i2 = File.createTempFile("include2", ".ctl") @@ -101,18 +101,18 @@ class References { val result = parser.parse( "m = !l \n" + - "#include \"${ i1.getAbsolutePath() }\" \n" + - "#include \"${ i2.getAbsolutePath() }\" \n" + "#include \"${ i1.absolutePath }\" \n" + + "#include \"${ i2.absolutePath }\" \n" ) assertEquals(3, result.size()) - assertEquals(True, result.get("k")) - assertEquals(EF(True), result.get("l")) - assertEquals(not(EF(True)), result.get("m")) + assertEquals(True, result["k"]) + assertEquals(EF(True), result["l"]) + assertEquals(not(EF(True)), result["m"]) } - Test fun transitiveResolveInString() { + @Test fun transitiveResolveInString() { val result = parser.parse(""" k = True @@ -121,13 +121,13 @@ class References { """) assertEquals(3, result.size()) - assertEquals(True, result.get("k")) - assertEquals(EF(True), result.get("l")) - assertEquals(not(EF(True)), result.get("m")) + assertEquals(True, result["k"]) + assertEquals(EF(True), result["l"]) + assertEquals(not(EF(True)), result["m"]) } - Test fun simpleResolveInInclude() { + @Test fun simpleResolveInInclude() { val i = File.createTempFile("include", ".ctl") @@ -137,35 +137,35 @@ class References { val result = parser.parse( "k = !val \n " + - "#include \"${ i.getAbsoluteFile() }\" \n" + "#include \"${ i.absolutePath }\" \n" ) assertEquals(2, result.size()) - assertEquals(False, result.get("val")) - assertEquals(not(False), result.get("k")) + assertEquals(False, result["val"]) + assertEquals(not(False), result["k"]) i.delete() } - Test fun simpleResolveInString() { + @Test fun simpleResolveInString() { val result = parser.parse(""" k = True l = !k """) assertEquals(2, result.size()) - assertEquals(True, result.get("k")) - assertEquals(not(True), result.get("l")) + assertEquals(True, result["k"]) + assertEquals(not(True), result["l"]) } - Test fun aliasInString() { + @Test fun aliasInString() { val result = parser.parse(""" k = True l = k """) assertEquals(2, result.size()) - assertEquals(True, result.get("k")) - assertEquals(True, result.get("l")) + assertEquals(True, result["k"]) + assertEquals(True, result["l"]) } } \ No newline at end of file