From 1c2195e727aaed3afe604eb602b105d7fa1f917d Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Mon, 5 Oct 2015 17:05:12 +0100 Subject: Rename generic backend tests to method tests --- .../zwobble/couscous/tests/BackendMethodTests.java | 104 +++++++++++++++++ .../org/zwobble/couscous/tests/BackendTests.java | 104 ----------------- .../backends/python/PythonCompilerMethodTests.java | 84 ++++++++++++++ .../tests/backends/python/PythonCompilerTests.java | 84 -------------- .../tests/interpreter/InterpreterMethodTests.java | 123 +++++++++++++++++++++ .../tests/interpreter/InterpreterTests.java | 123 --------------------- 6 files changed, 311 insertions(+), 311 deletions(-) create mode 100644 src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java delete mode 100644 src/test/java/org/zwobble/couscous/tests/BackendTests.java create mode 100644 src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerMethodTests.java delete mode 100644 src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java create mode 100644 src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java delete mode 100644 src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java (limited to 'src/test/java/org') diff --git a/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java b/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java new file mode 100644 index 0000000..b55a2ca --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/BackendMethodTests.java @@ -0,0 +1,104 @@ +package org.zwobble.couscous.tests; + +import org.junit.Test; +import org.zwobble.couscous.ast.AssignmentNode; +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.ast.ExpressionStatementNode; +import org.zwobble.couscous.ast.LiteralNode; +import org.zwobble.couscous.ast.MethodNode; +import org.zwobble.couscous.ast.ReturnNode; +import org.zwobble.couscous.values.PrimitiveValue; +import org.zwobble.couscous.values.PrimitiveValues; +import org.zwobble.couscous.values.StringValue; + +import static java.util.Arrays.asList; +import static org.junit.Assert.assertEquals; +import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg; +import static org.zwobble.couscous.ast.LiteralNode.literal; +import static org.zwobble.couscous.ast.LocalVariableDeclarationNode.localVariableDeclaration; +import static org.zwobble.couscous.ast.MethodNode.staticMethod; +import static org.zwobble.couscous.ast.VariableDeclaration.var; +import static org.zwobble.couscous.ast.VariableReferenceNode.reference; +import static org.zwobble.couscous.values.PrimitiveValues.value; + +import lombok.val; + +public abstract class BackendMethodTests { + @Test + public void methodWithNoStatementsReturnsUnit() { + val method = staticMethod("hello"); + val result = runMethod(method); + + assertEquals(PrimitiveValues.UNIT, result); + } + + @Test + public void canReturnLiteralValue() { + val method = staticMethod("hello") + .statement(new ReturnNode(literal("hello, world!"))); + val result = runMethod(method); + + assertEquals(value("hello, world!"), result); + } + @Test + public void canPassValueToMethod() { + val arg = formalArg(var(42, "x", StringValue.REF)); + val method = staticMethod("hello") + .argument(arg) + .statement(new ReturnNode(reference(arg))); + val result = runMethod(method, value("hello, world!")); + + assertEquals(value("hello, world!"), result); + } + + @Test + public void canReassignValueToArgument() { + val arg = formalArg(var(42, "x", StringValue.REF)); + val method = staticMethod("hello") + .argument(arg) + .statement(new ExpressionStatementNode(new AssignmentNode(reference(arg), LiteralNode.literal("[updated value]")))) + .statement(new ReturnNode(reference(arg))); + val result = runMethod(method, value("[initial value]")); + + assertEquals(value("[updated value]"), result); + } + + @Test + public void canDeclareVariable() { + val localVariableDeclaration = localVariableDeclaration( + 42, "x", StringValue.REF, LiteralNode.literal("[initial value]")); + val method = staticMethod("hello") + .statement(localVariableDeclaration) + .statement(new ReturnNode(reference(localVariableDeclaration))); + val result = runMethod(method); + + assertEquals(value("[initial value]"), result); + } + + @Test + public void canDeclareVariableAndThenAssignValues() { + val localVariableDeclaration = localVariableDeclaration( + 42, "x", StringValue.REF, LiteralNode.literal("[initial value]")); + val method = staticMethod("hello") + .statement(localVariableDeclaration) + .statement(new ExpressionStatementNode(new AssignmentNode(reference(localVariableDeclaration), LiteralNode.literal("[updated value]")))) + .statement(new ReturnNode(reference(localVariableDeclaration))); + val result = runMethod(method); + + assertEquals(value("[updated value]"), result); + } + + protected PrimitiveValue runMethod(MethodNode.MethodNodeBuilder methodBuilder, PrimitiveValue... arguments) { + val method = methodBuilder.build(); + val className = "com.example.Program"; + val classNode = ClassNode.builder(className) + .method(method) + .build(); + + val runner = buildMethodRunner(); + return runner.runMethod(classNode, method.getName(), asList(arguments)); + } + + protected abstract MethodRunner buildMethodRunner(); + +} diff --git a/src/test/java/org/zwobble/couscous/tests/BackendTests.java b/src/test/java/org/zwobble/couscous/tests/BackendTests.java deleted file mode 100644 index dc13469..0000000 --- a/src/test/java/org/zwobble/couscous/tests/BackendTests.java +++ /dev/null @@ -1,104 +0,0 @@ -package org.zwobble.couscous.tests; - -import org.junit.Test; -import org.zwobble.couscous.ast.AssignmentNode; -import org.zwobble.couscous.ast.ClassNode; -import org.zwobble.couscous.ast.ExpressionStatementNode; -import org.zwobble.couscous.ast.LiteralNode; -import org.zwobble.couscous.ast.MethodNode; -import org.zwobble.couscous.ast.ReturnNode; -import org.zwobble.couscous.values.PrimitiveValue; -import org.zwobble.couscous.values.PrimitiveValues; -import org.zwobble.couscous.values.StringValue; - -import static java.util.Arrays.asList; -import static org.junit.Assert.assertEquals; -import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg; -import static org.zwobble.couscous.ast.LiteralNode.literal; -import static org.zwobble.couscous.ast.LocalVariableDeclarationNode.localVariableDeclaration; -import static org.zwobble.couscous.ast.MethodNode.staticMethod; -import static org.zwobble.couscous.ast.VariableDeclaration.var; -import static org.zwobble.couscous.ast.VariableReferenceNode.reference; -import static org.zwobble.couscous.values.PrimitiveValues.value; - -import lombok.val; - -public abstract class BackendTests { - @Test - public void methodWithNoStatementsReturnsUnit() { - val method = staticMethod("hello"); - val result = runMethod(method); - - assertEquals(PrimitiveValues.UNIT, result); - } - - @Test - public void canReturnLiteralValue() { - val method = staticMethod("hello") - .statement(new ReturnNode(literal("hello, world!"))); - val result = runMethod(method); - - assertEquals(value("hello, world!"), result); - } - @Test - public void canPassValueToMethod() { - val arg = formalArg(var(42, "x", StringValue.REF)); - val method = staticMethod("hello") - .argument(arg) - .statement(new ReturnNode(reference(arg))); - val result = runMethod(method, value("hello, world!")); - - assertEquals(value("hello, world!"), result); - } - - @Test - public void canReassignValueToArgument() { - val arg = formalArg(var(42, "x", StringValue.REF)); - val method = staticMethod("hello") - .argument(arg) - .statement(new ExpressionStatementNode(new AssignmentNode(reference(arg), LiteralNode.literal("[updated value]")))) - .statement(new ReturnNode(reference(arg))); - val result = runMethod(method, value("[initial value]")); - - assertEquals(value("[updated value]"), result); - } - - @Test - public void canDeclareVariable() { - val localVariableDeclaration = localVariableDeclaration( - 42, "x", StringValue.REF, LiteralNode.literal("[initial value]")); - val method = staticMethod("hello") - .statement(localVariableDeclaration) - .statement(new ReturnNode(reference(localVariableDeclaration))); - val result = runMethod(method); - - assertEquals(value("[initial value]"), result); - } - - @Test - public void canDeclareVariableAndThenAssignValues() { - val localVariableDeclaration = localVariableDeclaration( - 42, "x", StringValue.REF, LiteralNode.literal("[initial value]")); - val method = staticMethod("hello") - .statement(localVariableDeclaration) - .statement(new ExpressionStatementNode(new AssignmentNode(reference(localVariableDeclaration), LiteralNode.literal("[updated value]")))) - .statement(new ReturnNode(reference(localVariableDeclaration))); - val result = runMethod(method); - - assertEquals(value("[updated value]"), result); - } - - protected PrimitiveValue runMethod(MethodNode.MethodNodeBuilder methodBuilder, PrimitiveValue... arguments) { - val method = methodBuilder.build(); - val className = "com.example.Program"; - val classNode = ClassNode.builder(className) - .method(method) - .build(); - - val runner = buildMethodRunner(); - return runner.runMethod(classNode, method.getName(), asList(arguments)); - } - - protected abstract MethodRunner buildMethodRunner(); - -} diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerMethodTests.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerMethodTests.java new file mode 100644 index 0000000..93c283a --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerMethodTests.java @@ -0,0 +1,84 @@ +package org.zwobble.couscous.tests.backends.python; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.file.Files; +import java.util.List; + +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.backends.python.PythonCodeGenerator; +import org.zwobble.couscous.backends.python.PythonCompiler; +import org.zwobble.couscous.backends.python.PythonSerializer; +import org.zwobble.couscous.tests.BackendMethodTests; +import org.zwobble.couscous.tests.MethodRunner; +import org.zwobble.couscous.values.PrimitiveValue; +import org.zwobble.couscous.values.PrimitiveValues; + +import com.google.common.base.Charsets; +import com.google.common.base.Joiner; +import com.google.common.io.CharStreams; + +import static java.lang.Integer.parseInt; +import static java.util.Arrays.asList; +import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively; +import static org.zwobble.couscous.values.PrimitiveValues.value; + +import lombok.SneakyThrows; +import lombok.val; + +public class PythonCompilerMethodTests extends BackendMethodTests { + @Override + protected MethodRunner buildMethodRunner() { + return new MethodRunner() { + @Override + @SneakyThrows + public PrimitiveValue runMethod( + ClassNode classNode, + String methodName, + List arguments) { + val compiler = new PythonCompiler(); + val directoryPath = Files.createTempDirectory(null); + try { + compiler.compile(asList(classNode), directoryPath); + + val argumentsString = Joiner.on(", ").join(arguments.stream() + .map(PythonCodeGenerator::generateCode) + .map(PythonSerializer::serialize) + .iterator()); + + val program = "from " + classNode.getName() + " import " + classNode.getLocalName() + + ";print(repr(" + classNode.getLocalName() + "." + methodName + "(" + argumentsString + ")))"; + + val process = new ProcessBuilder("python3.4", "-c", program) + .directory(directoryPath.toFile()) + .start(); + val exitCode = process.waitFor(); + val output = readString(process.getInputStream()).trim(); + val stderrOutput = readString(process.getErrorStream()); + if (exitCode != 0) { + throw new RuntimeException("stderr was: " + stderrOutput); + } else { + return readPrimitive(output); + } + } finally { + deleteRecursively(directoryPath.toFile()); + } + } + + private PrimitiveValue readPrimitive(String output) { + if (output.equals("None")) { + return PrimitiveValues.UNIT; + } else if (output.startsWith("'")) { + return value(output.substring(1, output.length() - 1)); + } else { + return value(parseInt(output)); + } + } + + private String readString(final InputStream stream) throws IOException { + return CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8)); + } + }; + } +} diff --git a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java b/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java deleted file mode 100644 index 2df13b9..0000000 --- a/src/test/java/org/zwobble/couscous/tests/backends/python/PythonCompilerTests.java +++ /dev/null @@ -1,84 +0,0 @@ -package org.zwobble.couscous.tests.backends.python; - -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.nio.file.Files; -import java.util.List; - -import org.zwobble.couscous.ast.ClassNode; -import org.zwobble.couscous.backends.python.PythonCodeGenerator; -import org.zwobble.couscous.backends.python.PythonCompiler; -import org.zwobble.couscous.backends.python.PythonSerializer; -import org.zwobble.couscous.tests.BackendTests; -import org.zwobble.couscous.tests.MethodRunner; -import org.zwobble.couscous.values.PrimitiveValue; -import org.zwobble.couscous.values.PrimitiveValues; - -import com.google.common.base.Charsets; -import com.google.common.base.Joiner; -import com.google.common.io.CharStreams; - -import static java.lang.Integer.parseInt; -import static java.util.Arrays.asList; -import static org.zwobble.couscous.tests.util.ExtraFiles.deleteRecursively; -import static org.zwobble.couscous.values.PrimitiveValues.value; - -import lombok.SneakyThrows; -import lombok.val; - -public class PythonCompilerTests extends BackendTests { - @Override - protected MethodRunner buildMethodRunner() { - return new MethodRunner() { - @Override - @SneakyThrows - public PrimitiveValue runMethod( - ClassNode classNode, - String methodName, - List arguments) { - val compiler = new PythonCompiler(); - val directoryPath = Files.createTempDirectory(null); - try { - compiler.compile(asList(classNode), directoryPath); - - val argumentsString = Joiner.on(", ").join(arguments.stream() - .map(PythonCodeGenerator::generateCode) - .map(PythonSerializer::serialize) - .iterator()); - - val program = "from " + classNode.getName() + " import " + classNode.getLocalName() + - ";print(repr(" + classNode.getLocalName() + "." + methodName + "(" + argumentsString + ")))"; - - val process = new ProcessBuilder("python3.4", "-c", program) - .directory(directoryPath.toFile()) - .start(); - val exitCode = process.waitFor(); - val output = readString(process.getInputStream()).trim(); - val stderrOutput = readString(process.getErrorStream()); - if (exitCode != 0) { - throw new RuntimeException("stderr was: " + stderrOutput); - } else { - return readPrimitive(output); - } - } finally { - deleteRecursively(directoryPath.toFile()); - } - } - - private PrimitiveValue readPrimitive(String output) { - if (output.equals("None")) { - return PrimitiveValues.UNIT; - } else if (output.startsWith("'")) { - return value(output.substring(1, output.length() - 1)); - } else { - return value(parseInt(output)); - } - } - - private String readString(final InputStream stream) throws IOException { - return CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8)); - } - }; - } -} diff --git a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java new file mode 100644 index 0000000..26939dc --- /dev/null +++ b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterMethodTests.java @@ -0,0 +1,123 @@ +package org.zwobble.couscous.tests.interpreter; + +import java.util.List; +import java.util.stream.Collectors; + +import org.junit.Test; +import org.zwobble.couscous.MapBackedProject; +import org.zwobble.couscous.ast.AssignmentNode; +import org.zwobble.couscous.ast.ClassNode; +import org.zwobble.couscous.ast.ExpressionStatementNode; +import org.zwobble.couscous.ast.LiteralNode; +import org.zwobble.couscous.ast.ReturnNode; +import org.zwobble.couscous.interpreter.Interpreter; +import org.zwobble.couscous.interpreter.UnboundVariable; +import org.zwobble.couscous.interpreter.UnexpectedValueType; +import org.zwobble.couscous.interpreter.VariableNotInScope; +import org.zwobble.couscous.interpreter.WrongNumberOfArguments; +import org.zwobble.couscous.interpreter.values.ConcreteType; +import org.zwobble.couscous.interpreter.values.InterpreterValues; +import org.zwobble.couscous.tests.BackendMethodTests; +import org.zwobble.couscous.tests.MethodRunner; +import org.zwobble.couscous.values.IntegerValue; +import org.zwobble.couscous.values.PrimitiveValue; +import org.zwobble.couscous.values.StringValue; + +import com.google.common.collect.ImmutableMap; + +import static org.junit.Assert.assertEquals; +import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg; +import static org.zwobble.couscous.ast.LiteralNode.literal; +import static org.zwobble.couscous.ast.LocalVariableDeclarationNode.localVariableDeclaration; +import static org.zwobble.couscous.ast.MethodNode.staticMethod; +import static org.zwobble.couscous.ast.VariableDeclaration.var; +import static org.zwobble.couscous.ast.VariableReferenceNode.reference; +import static org.zwobble.couscous.tests.util.ExtraAsserts.assertThrows; +import static org.zwobble.couscous.values.PrimitiveValues.value; + +import lombok.val; + +public class InterpreterMethodTests extends BackendMethodTests { + @Test + public void errorIfWrongNumberOfArgumentsArePassed() { + val method = staticMethod("hello"); + + val exception = assertThrows(WrongNumberOfArguments.class, + () -> runMethod(method, value("hello, world!"))); + + assertEquals(new WrongNumberOfArguments(0, 1), exception); + } + + @Test + public void errorIfTryingToAssignValueOfWrongTypeToVariable() { + val arg = formalArg(var(42, "x", StringValue.REF)); + val method = staticMethod("hello") + .argument(arg) + .statement(new ExpressionStatementNode(new AssignmentNode(reference(arg), literal(0)))); + + val exception = assertThrows(UnexpectedValueType.class, + () -> runMethod(method, value(""))); + + assertEquals(new UnexpectedValueType(StringValue.REF, IntegerValue.REF), exception); + } + + @Test + public void errorIfTryingToAssignToVariableNotInScope() { + val localVariableDeclaration = localVariableDeclaration( + 42, "x", StringValue.REF, literal("")); + val method = staticMethod("hello") + .statement(new ExpressionStatementNode(new AssignmentNode(reference(localVariableDeclaration), LiteralNode.literal("[updated value]")))); + + val exception = assertThrows(VariableNotInScope.class, + () -> runMethod(method)); + + assertEquals(new VariableNotInScope(42), exception); + } + + @Test + public void errorIfTryingToGetValueOfVariableNotInScope() { + val localVariableDeclaration = localVariableDeclaration( + 42, "x", StringValue.REF, literal("")); + val method = staticMethod("hello") + .statement(new ReturnNode(reference(localVariableDeclaration))); + + val exception = assertThrows(VariableNotInScope.class, + () -> runMethod(method)); + + assertEquals(new VariableNotInScope(42), exception); + } + + @Test + public void errorIfTryingToGetValueOfUnboundVariable() { + val localVariableDeclaration = localVariableDeclaration( + 42, "x", StringValue.REF, literal("")); + val method = staticMethod("hello") + .statement(new ReturnNode(reference(localVariableDeclaration))) + .statement(localVariableDeclaration); + + val exception = assertThrows(UnboundVariable.class, + () -> runMethod(method)); + + assertEquals(new UnboundVariable(42), exception); + } + + @Override + protected MethodRunner buildMethodRunner() { + return new MethodRunner() { + @Override + public PrimitiveValue runMethod( + ClassNode classNode, + String methodName, + List arguments) { + val interpreter = new Interpreter(new MapBackedProject(ImmutableMap.of( + classNode.getName(), ConcreteType.fromNode(classNode)))); + val argumentValues = arguments.stream() + .map(InterpreterValues::value) + .collect(Collectors.toList()); + + return interpreter.run(classNode.getName(), methodName, argumentValues) + .toPrimitiveValue().get(); + } + }; + } +} diff --git a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java b/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java deleted file mode 100644 index 5ccdd43..0000000 --- a/src/test/java/org/zwobble/couscous/tests/interpreter/InterpreterTests.java +++ /dev/null @@ -1,123 +0,0 @@ -package org.zwobble.couscous.tests.interpreter; - -import java.util.List; -import java.util.stream.Collectors; - -import org.junit.Test; -import org.zwobble.couscous.MapBackedProject; -import org.zwobble.couscous.ast.AssignmentNode; -import org.zwobble.couscous.ast.ClassNode; -import org.zwobble.couscous.ast.ExpressionStatementNode; -import org.zwobble.couscous.ast.LiteralNode; -import org.zwobble.couscous.ast.ReturnNode; -import org.zwobble.couscous.interpreter.Interpreter; -import org.zwobble.couscous.interpreter.UnboundVariable; -import org.zwobble.couscous.interpreter.UnexpectedValueType; -import org.zwobble.couscous.interpreter.VariableNotInScope; -import org.zwobble.couscous.interpreter.WrongNumberOfArguments; -import org.zwobble.couscous.interpreter.values.ConcreteType; -import org.zwobble.couscous.interpreter.values.InterpreterValues; -import org.zwobble.couscous.tests.BackendTests; -import org.zwobble.couscous.tests.MethodRunner; -import org.zwobble.couscous.values.IntegerValue; -import org.zwobble.couscous.values.PrimitiveValue; -import org.zwobble.couscous.values.StringValue; - -import com.google.common.collect.ImmutableMap; - -import static org.junit.Assert.assertEquals; -import static org.zwobble.couscous.ast.FormalArgumentNode.formalArg; -import static org.zwobble.couscous.ast.LiteralNode.literal; -import static org.zwobble.couscous.ast.LocalVariableDeclarationNode.localVariableDeclaration; -import static org.zwobble.couscous.ast.MethodNode.staticMethod; -import static org.zwobble.couscous.ast.VariableDeclaration.var; -import static org.zwobble.couscous.ast.VariableReferenceNode.reference; -import static org.zwobble.couscous.tests.util.ExtraAsserts.assertThrows; -import static org.zwobble.couscous.values.PrimitiveValues.value; - -import lombok.val; - -public class InterpreterTests extends BackendTests { - @Test - public void errorIfWrongNumberOfArgumentsArePassed() { - val method = staticMethod("hello"); - - val exception = assertThrows(WrongNumberOfArguments.class, - () -> runMethod(method, value("hello, world!"))); - - assertEquals(new WrongNumberOfArguments(0, 1), exception); - } - - @Test - public void errorIfTryingToAssignValueOfWrongTypeToVariable() { - val arg = formalArg(var(42, "x", StringValue.REF)); - val method = staticMethod("hello") - .argument(arg) - .statement(new ExpressionStatementNode(new AssignmentNode(reference(arg), literal(0)))); - - val exception = assertThrows(UnexpectedValueType.class, - () -> runMethod(method, value(""))); - - assertEquals(new UnexpectedValueType(StringValue.REF, IntegerValue.REF), exception); - } - - @Test - public void errorIfTryingToAssignToVariableNotInScope() { - val localVariableDeclaration = localVariableDeclaration( - 42, "x", StringValue.REF, literal("")); - val method = staticMethod("hello") - .statement(new ExpressionStatementNode(new AssignmentNode(reference(localVariableDeclaration), LiteralNode.literal("[updated value]")))); - - val exception = assertThrows(VariableNotInScope.class, - () -> runMethod(method)); - - assertEquals(new VariableNotInScope(42), exception); - } - - @Test - public void errorIfTryingToGetValueOfVariableNotInScope() { - val localVariableDeclaration = localVariableDeclaration( - 42, "x", StringValue.REF, literal("")); - val method = staticMethod("hello") - .statement(new ReturnNode(reference(localVariableDeclaration))); - - val exception = assertThrows(VariableNotInScope.class, - () -> runMethod(method)); - - assertEquals(new VariableNotInScope(42), exception); - } - - @Test - public void errorIfTryingToGetValueOfUnboundVariable() { - val localVariableDeclaration = localVariableDeclaration( - 42, "x", StringValue.REF, literal("")); - val method = staticMethod("hello") - .statement(new ReturnNode(reference(localVariableDeclaration))) - .statement(localVariableDeclaration); - - val exception = assertThrows(UnboundVariable.class, - () -> runMethod(method)); - - assertEquals(new UnboundVariable(42), exception); - } - - @Override - protected MethodRunner buildMethodRunner() { - return new MethodRunner() { - @Override - public PrimitiveValue runMethod( - ClassNode classNode, - String methodName, - List arguments) { - val interpreter = new Interpreter(new MapBackedProject(ImmutableMap.of( - classNode.getName(), ConcreteType.fromNode(classNode)))); - val argumentValues = arguments.stream() - .map(InterpreterValues::value) - .collect(Collectors.toList()); - - return interpreter.run(classNode.getName(), methodName, argumentValues) - .toPrimitiveValue().get(); - } - }; - } -} -- cgit v1.2.3