azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove testing Kotlin signature from WriteSignatureTest

Browse Source
This commit is contained in:
Pavel V. Talanov
2013-07-17 17:11:52 +04:00
parent 01735a0412
commit 5f108905d1
39 changed files with 67 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/jvm/compiler/WriteSignatureTest.java
+35 -140
View File
@@ -24,7 +24,6 @@ import junit.framework.Test;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.asm4.*;
import org.jetbrains.asm4.commons.Method;
import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
@@ -32,7 +31,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.codegen.ClassFileFactory;
import org.jetbrains.jet.codegen.GenerationUtils;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
import org.jetbrains.jet.test.TestCaseWithTmpdir;
import org.junit.Assert;
@@ -51,8 +49,6 @@ import java.util.regex.Pattern;
*/
public class WriteSignatureTest extends TestCaseWithTmpdir {
private static final AnnotationVisitor EMPTY_ANNOTATION_VISITOR = new AnnotationVisitor(Opcodes.ASM4) {};
private final File ktFile;
private JetCoreEnvironment jetCoreEnvironment;
@@ -96,27 +92,24 @@ public class WriteSignatureTest extends TestCaseWithTmpdir {
String template =
"jvm signature: %s\n" +
"generic signature: %s\n" +
"kotlin signature: %s\n" +
"";
String expected = String.format(template, expectation.jvmSignature, expectation.genericSignature, expectation.kotlinSignature);
String actual = String.format(template, actualSignature.jvmSignature, actualSignature.genericSignature, actualSignature.kotlinSignature);
String expected = String.format(template, expectation.jvmSignature, expectation.genericSignature);
String actual = String.format(template, actualSignature.jvmSignature, actualSignature.genericSignature);
Assert.assertEquals(expected, actual);
}
private static class ActualSignature {
private final String jvmSignature;
private final String genericSignature;
private final String kotlinSignature;
private ActualSignature(@NotNull String jvmSignature, @Nullable String genericSignature, @Nullable String kotlinSignature) {
private ActualSignature(@NotNull String jvmSignature, @Nullable String genericSignature) {
this.jvmSignature = jvmSignature;
this.genericSignature = genericSignature;
this.kotlinSignature = kotlinSignature;
}
}
@NotNull
private ActualSignature readSignature(String className, final String methodName) throws Exception {
// ugly unreadable code begin
@@ -133,143 +126,47 @@ public class WriteSignatureTest extends TestCaseWithTmpdir {
public MethodVisitor visitMethod(int access, String name, final String desc, final String signature, String[] exceptions) {
if (name.equals(methodName)) {
final int parameterCount = new Method(name, desc).getArgumentTypes().length;
return new MethodVisitor(Opcodes.ASM4) {
String typeParameters = "";
String returnType;
String[] parameterTypes = new String[parameterCount];
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
if (desc.equals(JvmStdlibNames.JET_METHOD.getDescriptor())) {
return new AnnotationVisitor(Opcodes.ASM4) {
@Override
public void visit(String name, Object value) {
if (name.equals(JvmStdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD)) {
typeParameters = (String) value;
}
else if (name.equals(JvmStdlibNames.JET_METHOD_RETURN_TYPE_FIELD)) {
returnType = (String) value;
}
}
@Override
public AnnotationVisitor visitAnnotation(String s, String s1) {
return EMPTY_ANNOTATION_VISITOR;
}
@Override
public AnnotationVisitor visitArray(String name) {
return EMPTY_ANNOTATION_VISITOR;
}
};
}
else {
return EMPTY_ANNOTATION_VISITOR;
}
}
@Override
public AnnotationVisitor visitParameterAnnotation(final int parameter, String desc, boolean visible) {
if (desc.equals(JvmStdlibNames.JET_VALUE_PARAMETER.getDescriptor())) {
return new AnnotationVisitor(Opcodes.ASM4) {
@Override
public void visit(String name, Object value) {
if (name.equals(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD)) {
parameterTypes[parameter] = (String) value;
}
}
@Override
public AnnotationVisitor visitAnnotation(String name, String desc) {
return EMPTY_ANNOTATION_VISITOR;
}
@Override
public AnnotationVisitor visitArray(String name) {
return EMPTY_ANNOTATION_VISITOR;
}
};
}
else {
return EMPTY_ANNOTATION_VISITOR;
}
}
@Override
public AnnotationVisitor visitAnnotationDefault() {
return EMPTY_ANNOTATION_VISITOR;
}
@Nullable
private String makeKotlinSignature() {
boolean allNulls = true;
StringBuilder sb = new StringBuilder();
sb.append(typeParameters);
if (typeParameters != null && typeParameters.length() > 0) {
allNulls = false;
}
sb.append("(");
for (String parameterType : parameterTypes) {
sb.append(parameterType);
if (parameterType != null) {
allNulls = false;
}
}
sb.append(")");
sb.append(returnType);
if (returnType != null) {
allNulls = false;
}
if (allNulls) {
return null;
}
else {
return sb.toString();
}
}
@Override
public void visitEnd() {
Assert.assertNull(readSignature);
readSignature = new ActualSignature(desc, signature, makeKotlinSignature());
readSignature = new ActualSignature(desc, signature);
}
};
}
return super.visitMethod(access, name, desc, signature, exceptions);
}
}
Visitor visitor = new Visitor();
new ClassReader(classInputStream).accept(visitor,
ClassReader.SKIP_CODE|ClassReader.SKIP_DEBUG|ClassReader.SKIP_FRAMES);
ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
Assert.assertNotNull("method not found: " + className + "::" + methodName, visitor.readSignature);
return visitor.readSignature;
} finally {
}
finally {
Closeables.closeQuietly(classInputStream);
}
// ugly unreadable code end
}
private static class Expectation {
private final String className;
private final String methodName;
private final String jvmSignature;
private final String genericSignature;
private final String kotlinSignature;
private Expectation(@NotNull String className, @NotNull String methodName,
@NotNull String jvmSignature, @Nullable String genericSignature, @Nullable String kotlinSignature) {
private Expectation(
@NotNull String className, @NotNull String methodName,
@NotNull String jvmSignature, @Nullable String genericSignature
) {
this.className = className;
this.methodName = methodName;
this.jvmSignature = jvmSignature;
this.genericSignature = genericSignature;
this.kotlinSignature = kotlinSignature;
}
}
@@ -277,46 +174,44 @@ public class WriteSignatureTest extends TestCaseWithTmpdir {
private static final Pattern methodPattern = Pattern.compile("^// method: *(.*)::(.*?) *(//.*)?");
private static final Pattern jvmSignaturePattern = Pattern.compile("^// jvm signature: *(.+?) *(//.*)?");
private static final Pattern genericSignaturePattern = Pattern.compile("^// generic signature: *(.+?) *(//.*)?");
private static final Pattern kotlinSignaturePattern = Pattern.compile("^// kotlin signature: *(.+?) *(//.*)?");
private Expectation parseExpectations() throws IOException {
List<String> lines = Files.readLines(ktFile, Charset.forName("utf-8"));
for (int i = 0; i < lines.size() - 3; ++i) {
for (int i = 0; i < lines.size() - 2; ++i) {
Matcher methodMatcher = methodPattern.matcher(lines.get(i));
if (methodMatcher.matches()) {
Matcher jvmSignatureMatcher = jvmSignaturePattern.matcher(lines.get(i + 1));
Matcher genericSignatureMatcher = genericSignaturePattern.matcher(lines.get(i + 2));
Matcher kotlinSignatureMatcher = kotlinSignaturePattern.matcher(lines.get(i + 3));
if (!jvmSignatureMatcher.matches() || !genericSignatureMatcher.matches() || !kotlinSignatureMatcher.matches()) {
if (!jvmSignatureMatcher.matches() || !genericSignatureMatcher.matches()) {
throw new AssertionError("'method:' must be followed ... bla bla ... use the source luke");
}
String className = methodMatcher.group(1);
String methodName = methodMatcher.group(2);
String jvmSignature = jvmSignatureMatcher.group(1);
String genericSignature = genericSignatureMatcher.group(1);
String kotlinSignature = kotlinSignatureMatcher.group(1);
if (genericSignature.equals("null")) {
genericSignature = null;
}
if (kotlinSignature.equals("null")) {
kotlinSignature = null;
}
return new Expectation(className, methodName, jvmSignature, genericSignature, kotlinSignature);
return new Expectation(className, methodName, jvmSignature, genericSignature);
}
}
throw new AssertionError("test instructions not found in " + ktFile);
}
public static Test suite() {
return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/writeSignature", true, new JetTestCaseBuilder.NamedTestFactory() {
@NotNull
@Override
public Test createTest(@NotNull String dataPath, @NotNull String name, @NotNull File file) {
return new WriteSignatureTest(file);
}
});
return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/writeSignature", true,
new JetTestCaseBuilder.NamedTestFactory() {
@NotNull
@Override
public Test createTest(
@NotNull String dataPath,
@NotNull String name,
@NotNull File file
) {
return new WriteSignatureTest(file);
}
});
}
}