From 6a455fe6da5ff9c741d91279a2dc6fe2fb1b472f Mon Sep 17 00:00:00 2001 From: Felix Mulder Date: Tue, 1 Nov 2016 18:34:29 +0100 Subject: Move (most) unit tests to correct locations Should still perhaps move `test/dotc/tests.scala` and the others in the same directory to a better more cohesive location. Would like to delete the worksheets as well - but maybe they hold sentimental value... --- .../tools/dotc/transform/TreeTransformerTest.scala | 198 +++++++++++++++++++++ 1 file changed, 198 insertions(+) create mode 100644 test/dotty/tools/dotc/transform/TreeTransformerTest.scala (limited to 'test/dotty/tools/dotc/transform/TreeTransformerTest.scala') diff --git a/test/dotty/tools/dotc/transform/TreeTransformerTest.scala b/test/dotty/tools/dotc/transform/TreeTransformerTest.scala new file mode 100644 index 000000000..d72980d80 --- /dev/null +++ b/test/dotty/tools/dotc/transform/TreeTransformerTest.scala @@ -0,0 +1,198 @@ +package dotty.tools +package dotc +package transform + +import org.junit.{Assert, Test} +import TreeTransforms.{TransformerInfo, TreeTransformer, MiniPhaseTransform} +import ast.tpd +import core.Constants.Constant +import core.Contexts.Context + +class TreeTransformerTest extends DottyTest { + + @Test + def shouldReturnSameTreeIfUnchanged = checkCompile("frontend", "class A{ val d = 1}") { + (tree, context) => + implicit val ctx = context + class EmptyTransform extends MiniPhaseTransform { + override def phaseName: String = "empty" + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + val transformer = new TreeTransformer { + override def miniPhases = Array(new EmptyTransform) + + override def phaseName: String = "test" + } + val transformed = transformer.macroTransform(tree) + + Assert.assertTrue("returns same tree if unmodified", + tree eq transformed + ) + } + + // Disabled, awaiting resolution. @Test + def canReplaceConstant = checkCompile("frontend", "class A{ val d = 1}") { + (tree, context) => + implicit val ctx = context + class ConstantTransform extends MiniPhaseTransform { + + override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = tpd.Literal(Constant(2)) + override def phaseName: String = "canReplaceConstant" + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + val transformer = new TreeTransformer { + override def miniPhases = Array(new ConstantTransform) + + override def phaseName: String = "test" + } + val transformed = transformer.macroTransform(tree) + + Assert.assertTrue("returns same tree if unmodified", + transformed.toString.contains("List(ValDef(Modifiers(,,List()),d,TypeTree[TypeRef(ThisType(module class scala),Int)],Literal(Constant(2)))") + ) + } + + @Test + def canOverwrite = checkCompile("frontend", "class A{ val d = 1}") { + (tree, context) => + implicit val ctx = context + class Transformation extends MiniPhaseTransform { + + override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = tpd.Literal(Constant(-1)) + override def phaseName: String = "canOverwrite" + + override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo): tpd.ValDef = { + Assert.assertTrue("transformation of children succeeded", + tree.rhs.toString == "Literal(Constant(-1))" + ) + tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(2))) + } + + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + val transformer = new TreeTransformer { + override def miniPhases = Array(new Transformation) + + override def phaseName: String = "test" + + } + val tr = transformer.macroTransform(tree).toString + + Assert.assertTrue("node can rewrite children", + tr.contains("Literal(Constant(2))") && !tr.contains("Literal(Constant(-1))") + ) + } + + @Test + def transformationOrder = checkCompile("frontend", "class A{ val d = 1}") { + (tree, context) => + implicit val ctx = context + class Transformation1 extends MiniPhaseTransform { + override def phaseName: String = "transformationOrder1" + + override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { + Assert.assertTrue("correct constant", + tree.const.toString == "Constant(1)" + ) + tpd.cpy.Literal(tree)(Constant(-1)) + } + + override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo): tpd.ValDef = { + Assert.assertTrue("transformation of children succeeded", + tree.rhs.toString == "Literal(Constant(-1))" + ) + tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(2))) + } + + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + class Transformation2 extends MiniPhaseTransform { + override def phaseName: String = "transformationOrder2" + override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo): tpd.ValDef = { + Assert.assertTrue("transformation of children succeeded", + tree.rhs.toString == "Literal(Constant(2))" + ) + tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(3))) + } + + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + val transformer = new TreeTransformer { + override def miniPhases = Array(new Transformation1, new Transformation2) + + override def phaseName: String = "test" + } + val tr = transformer.macroTransform(tree).toString + + Assert.assertTrue("node can rewrite children", + tr.contains("Literal(Constant(3))") + ) + } + + @Test + def invocationCount = checkCompile("frontend", "class A{ val d = 1}") { + (tree, context) => + implicit val ctx = context + var transformed1 = 0 + class Transformation1 extends MiniPhaseTransform { + override def phaseName: String = "invocationCount1" + override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { + transformed1 += 1 + Assert.assertTrue("correct constant", + tree.const.toString == "Constant(1)" + ) + tpd.cpy.Literal(tree)(Constant(-1)) + } + + override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo) = { + transformed1 += 1 + Assert.assertTrue("transformation of children succeeded", + tree.rhs.toString == "Literal(Constant(-3))" + ) + tpd.cpy.ValDef(tree)(rhs = transformFollowing(tpd.Literal(Constant(2)))) + } + + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + var transformed2 = 0 + class Transformation2 extends MiniPhaseTransform { + var constantsSeen = 0 + override def phaseName: String = "invocationCount2" + override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = { + transformed2 += 1 + constantsSeen match { + case 0 => + Assert.assertTrue("correct constant", + tree.const.toString == "Constant(-1)" + ) + case 1 => + Assert.assertTrue("correct constant", + tree.const.toString == "Constant(2)" + ) + case _ => Assert.fail("to many constants seen") + } + constantsSeen += 1 + tpd.cpy.Literal(tree)(Constant(-3)) + } + + override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context, info: TransformerInfo) = { + transformed2 += 1 + Assert.assertTrue("transformation of children succeeded", + tree.rhs.toString == "Literal(Constant(-3))" + ) + transformFollowing(tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(3)))) + } + + init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId) + } + val transformer = new TreeTransformer { + override def miniPhases = Array(new Transformation1, new Transformation2) + + override def phaseName: String = "test" + } + val tr = transformer.macroTransform(tree).toString + Assert.assertTrue("transformations aren't invoked multiple times", + transformed1 == 2 && transformed2 == 3 + ) + } +} -- cgit v1.2.3