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

Extract classPathInTheSameClassLoader into a separate test

Browse Source 
- class loader is now always created as if classPathInTheSameClassLoader
  = false, which was the case of every codegen test except kt2781, which
  is extracted into a separate file
- testNoClassObjectForJavaClass() is moved from StdlibTest since it has
  a custom createClassLoader() which doesn't work well in a java-interop
  case
- get rid of generateClassesInFileGetState
- several similar methods are inlined
This commit is contained in:
Alexander Udalov
2013-01-25 04:00:42 +04:00
committed by Alexander Udalov
parent 639aa9e218
commit 63aacc416f
8 changed files with 89 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java
+7 -8
View File
@@ -36,7 +36,7 @@ public class ClassGenTest extends CodegenTestCase {
public void testPSVMClass() {
loadFile("classes/simpleClass.kt");
final Class aClass = loadClass("SimpleClass", generateClassesInFile());
final Class aClass = generateClass("SimpleClass");
final Method[] methods = aClass.getDeclaredMethods();
// public int SimpleClass.foo()
assertEquals(1, methods.length);
@@ -44,7 +44,7 @@ public class ClassGenTest extends CodegenTestCase {
public void testArrayListInheritance() throws Exception {
loadFile("classes/inheritingFromArrayList.kt");
final Class aClass = loadClass("Foo", generateClassesInFile());
final Class aClass = generateClass("Foo");
assertInstanceOf(aClass.newInstance(), List.class);
}
@@ -159,8 +159,7 @@ public class ClassGenTest extends CodegenTestCase {
public void testAbstractMethod() throws Exception {
loadText("abstract class Foo { abstract fun x(): String; fun y(): Int = 0 }");
final ClassFileFactory codegens = generateClassesInFile();
final Class aClass = loadClass("Foo", codegens);
final Class aClass = generateClass("Foo");
assertNotNull(aClass.getMethod("x"));
assertNotNull(findMethodByName(aClass, "y"));
}
@@ -491,11 +490,11 @@ public class ClassGenTest extends CodegenTestCase {
blackBoxFile("regressions/kt2626.kt");
}
public void testKt2781() throws Exception {
blackBoxFileWithJava("regressions/kt2781.kt", true);
}
public void testKt2607() {
blackBoxFile("regressions/kt2607.kt");
}
public void testNoClassObjectForJavaClass() {
blackBoxFileWithJava("stdlib/noClassObjectForJavaClass.kt");
}
}
compiler/tests/org/jetbrains/jet/codegen/ClassPathInTheSameClassLoaderTest.java
+29
View File
@@ -0,0 +1,29 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.codegen;
public class ClassPathInTheSameClassLoaderTest extends CodegenTestCase {
@Override
protected GeneratedClassLoader createClassLoader(ClassFileFactory factory) {
initializedClassLoader = new GeneratedClassLoader(factory, CodegenTestCase.class.getClassLoader(), getClassPathURLs());
return initializedClassLoader;
}
public void testKt2781() {
blackBoxFileWithJava("regressions/kt2781.kt");
}
}
compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+29 -67
View File
@@ -58,7 +58,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
protected CodegenTestFiles myFiles;
private GenerationState alreadyGenerated;
private GeneratedClassLoader initializedClassLoader;
protected GeneratedClassLoader initializedClassLoader;
protected void createEnvironmentWithMockJdkAndIdeaAnnotations(@NotNull ConfigurationKind configurationKind) {
if (myEnvironment != null) {
@@ -124,27 +124,22 @@ public abstract class CodegenTestCase extends UsefulTestCase {
}
protected void blackBoxFile(String filename) {
blackBoxFile(filename, false);
}
private void blackBoxFile(String filename, boolean classPathInTheSameClassLoader) {
loadFile(filename);
blackBox(classPathInTheSameClassLoader);
blackBoxMultiFile(filename);
}
protected void blackBoxFileByFullPath(String filename) {
loadFileByFullPath(filename);
blackBox(false);
blackBox();
}
protected void blackBoxMultiFile(String... filenames) {
loadFiles(filenames);
blackBox(false);
blackBox();
}
private void blackBox(boolean classPathInTheSameClassLoader) {
private void blackBox() {
ClassFileFactory factory = generateClassesInFile();
GeneratedClassLoader loader = createClassLoader(factory, classPathInTheSameClassLoader);
GeneratedClassLoader loader = createClassLoader(factory);
JetFile firstFile = myFiles.getPsiFiles().get(0);
String fqName = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(firstFile)).getFqName().getFqName();
@@ -162,20 +157,16 @@ public abstract class CodegenTestCase extends UsefulTestCase {
}
protected void blackBoxFileWithJavaByFullPath(@NotNull String ktFile) {
blackBoxFileWithJava(ktFile.substring("compiler/testData/codegen/".length()), false);
blackBoxFileWithJava(ktFile.substring("compiler/testData/codegen/".length()));
}
protected void blackBoxFileWithJava(@NotNull String ktFile) {
blackBoxFileWithJava(ktFile, false);
}
protected void blackBoxFileWithJava(@NotNull String ktFile, boolean classPathInTheSameClassLoader) {
File javaClassesTempDirectory = compileJava(ktFile.replaceFirst("\\.kt$", ".java"));
myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests(
ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory));
blackBoxFile(ktFile, classPathInTheSameClassLoader);
blackBoxFile(ktFile);
}
protected File compileJava(@NotNull String filename) {
@@ -198,15 +189,17 @@ public abstract class CodegenTestCase extends UsefulTestCase {
}
}
protected GeneratedClassLoader createClassLoader(ClassFileFactory codegens) {
return createClassLoader(codegens, false);
}
protected GeneratedClassLoader createClassLoader(ClassFileFactory codegens, boolean classPathInTheSameClassLoader) {
protected GeneratedClassLoader createClassLoader(ClassFileFactory factory) {
if (initializedClassLoader != null) {
fail("Double initialization of class loader in same test");
}
ClassLoader parentClassLoader = new URLClassLoader(getClassPathURLs(), CodegenTestCase.class.getClassLoader());
initializedClassLoader = new GeneratedClassLoader(factory, parentClassLoader);
return initializedClassLoader;
}
protected URL[] getClassPathURLs() {
List<URL> urls = Lists.newArrayList();
for (File file : myEnvironment.getConfiguration().getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
try {
@@ -216,17 +209,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
}
}
final URL[] urlsArray = urls.toArray(new URL[urls.size()]);
if (!classPathInTheSameClassLoader) {
ClassLoader parentClassLoader = new URLClassLoader(urlsArray, CodegenTestCase.class.getClassLoader());
initializedClassLoader = new GeneratedClassLoader(codegens, parentClassLoader);
}
else {
initializedClassLoader = new GeneratedClassLoader(codegens, CodegenTestCase.class.getClassLoader(), urlsArray);
}
return initializedClassLoader;
return urls.toArray(new URL[urls.size()]);
}
protected String generateToText() {
@@ -258,55 +241,34 @@ public abstract class CodegenTestCase extends UsefulTestCase {
}
protected Class generateNamespaceClass() {
ClassFileFactory state = generateClassesInFile();
return loadRootNamespaceClass(state);
String name = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(myFiles.getPsiFile())).getFqName().getFqName();
return generateClass(name);
}
protected Class generateClass(String name) {
ClassFileFactory state = generateClassesInFile();
return loadClass(name, state);
}
protected Class loadRootNamespaceClass(@NotNull ClassFileFactory state) {
String fqName = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(myFiles.getPsiFile())).getFqName().getFqName();
try {
return createClassLoader(state).loadClass(fqName);
return createClassLoader(generateClassesInFile()).loadClass(name);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
protected Class loadClass(String fqName, @NotNull ClassFileFactory state) {
try {
return createClassLoader(state).loadClass(fqName);
} catch (ClassNotFoundException e) {
fail("No classfile was generated for: " + fqName);
fail("No class file was generated for: " + name);
return null;
}
}
@NotNull
protected ClassFileFactory generateClassesInFile() {
return generateClassesInFileGetState().getFactory();
}
@NotNull
protected GenerationState generateClassesInFileGetState() {
try {
if (alreadyGenerated == null) {
if (alreadyGenerated == null) {
try {
alreadyGenerated = generateCommon(myEnvironment, myFiles);
}
if (DxChecker.RUN_DX_CHECKER) {
DxChecker.check(alreadyGenerated.getFactory());
if (DxChecker.RUN_DX_CHECKER) {
DxChecker.check(alreadyGenerated.getFactory());
}
} catch (Throwable e) {
System.out.println(generateToText());
throw ExceptionUtils.rethrow(e);
}
return alreadyGenerated;
} catch (Throwable e) {
System.out.println(generateToText());
throw ExceptionUtils.rethrow(e);
}
return alreadyGenerated.getFactory();
}
protected Method generateFunction() {
compiler/tests/org/jetbrains/jet/codegen/EnumGenTest.java
+5 -5
View File
@@ -33,13 +33,13 @@ public class EnumGenTest extends CodegenTestCase {
public void testSuperclassIsEnum() throws NoSuchFieldException, IllegalAccessException {
loadFile("enum/simple.kt");
Class season = loadClass("Season", generateClassesInFile());
Class season = generateClass("Season");
assertEquals("java.lang.Enum", season.getSuperclass().getName());
}
public void testEnumClassModifiers() throws NoSuchFieldException, IllegalAccessException {
loadFile("enum/simple.kt");
Class season = loadClass("Season", generateClassesInFile());
Class season = generateClass("Season");
int modifiers = season.getModifiers();
assertTrue((modifiers & 0x4000) != 0); // ACC_ENUM
assertTrue((modifiers & Modifier.FINAL) != 0);
@@ -47,7 +47,7 @@ public class EnumGenTest extends CodegenTestCase {
public void testEnumFieldModifiers() throws NoSuchFieldException, IllegalAccessException {
loadFile("enum/simple.kt");
Class season = loadClass("Season", generateClassesInFile());
Class season = generateClass("Season");
Field summer = season.getField("SUMMER");
int modifiers = summer.getModifiers();
assertTrue((modifiers & 0x4000) != 0); // ACC_ENUM
@@ -120,7 +120,7 @@ public class EnumGenTest extends CodegenTestCase {
public void testNoClassForSimpleEnum()
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
loadFile("enum/name.kt");
Class cls = loadClass("State", generateClassesInFile());
Class cls = generateClass("State");
Field field = cls.getField("O");
assertEquals("State", field.get(null).getClass().getName());
}
@@ -128,7 +128,7 @@ public class EnumGenTest extends CodegenTestCase {
public void testYesClassForComplexEnum()
throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
loadFile("enum/abstractmethod.kt");
Class cls = loadClass("IssueState", generateClassesInFile());
Class cls = generateClass("IssueState");
Field field = cls.getField("DEFAULT");
assertEquals("IssueState", field.get(null).getClass().getName());
field = cls.getField("FIXED");
compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
+11 -13
View File
@@ -35,7 +35,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testPrivateVal() throws Exception {
loadFile();
final Class aClass = loadClass("PrivateVal", generateClassesInFile());
final Class aClass = generateClass("PrivateVal");
final Field[] fields = aClass.getDeclaredFields();
assertEquals(1, fields.length); // prop
final Field field = fields[0];
@@ -44,7 +44,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testPrivateVar() throws Exception {
loadFile();
final Class aClass = loadClass("PrivateVar", generateClassesInFile());
final Class aClass = generateClass("PrivateVar");
final Object instance = aClass.newInstance();
Method setter = findMethodByName(aClass, "setValueOfX");
setter.invoke(instance, 239);
@@ -54,7 +54,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testPublicVar() throws Exception {
loadText("class PublicVar() { public var foo : Int = 0; }");
final Class aClass = loadClass("PublicVar", generateClassesInFile());
final Class aClass = generateClass("PublicVar");
final Object instance = aClass.newInstance();
Method setter = findMethodByName(aClass, "setFoo");
setter.invoke(instance, 239);
@@ -64,7 +64,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testAccessorsInInterface() {
loadText("class AccessorsInInterface() { public var foo : Int = 0; }");
final Class aClass = loadClass("AccessorsInInterface", generateClassesInFile());
final Class aClass = generateClass("AccessorsInInterface");
assertNotNull(findMethodByName(aClass, "getFoo"));
assertNotNull(findMethodByName(aClass, "setFoo"));
}
@@ -116,7 +116,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testAccessorsWithoutBody() throws Exception {
loadText("class AccessorsWithoutBody() { protected var foo: Int = 349\n get\n private set\n fun setter() { foo = 610; } } ");
final Class aClass = loadClass("AccessorsWithoutBody", generateClassesInFile());
final Class aClass = generateClass("AccessorsWithoutBody");
final Object instance = aClass.newInstance();
final Method getFoo = findMethodByName(aClass, "getFoo");
getFoo.setAccessible(true);
@@ -139,7 +139,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testPropertyReceiverOnStack() throws Exception {
loadFile();
final Class aClass = loadClass("Evaluator", generateClassesInFile());
final Class aClass = generateClass("Evaluator");
final Constructor constructor = aClass.getConstructor(StringBuilder.class);
StringBuilder sb = new StringBuilder("xyzzy");
final Object instance = constructor.newInstance(sb);
@@ -150,15 +150,13 @@ public class PropertyGenTest extends CodegenTestCase {
public void testAbstractVal() throws Exception {
loadText("abstract class Foo { public abstract val x: String }");
final ClassFileFactory codegens = generateClassesInFile();
final Class aClass = loadClass("Foo", codegens);
final Class aClass = generateClass("Foo");
assertNotNull(aClass.getMethod("getX"));
}
public void testVolatileProperty() throws Exception {
loadText("abstract class Foo { public volatile var x: String = \"\"; }");
final ClassFileFactory codegens = generateClassesInFile();
final Class aClass = loadClass("Foo", codegens);
final Class aClass = generateClass("Foo");
Field x = aClass.getDeclaredField("x");
assertTrue((x.getModifiers() & Modifier.VOLATILE) != 0);
}
@@ -212,7 +210,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testKt1846() {
loadFile("regressions/kt1846.kt");
final Class aClass = loadClass("A", generateClassesInFile());
final Class aClass = generateClass("A");
try {
Method v1 = aClass.getMethod("getV1");
System.out.println(generateToText());
@@ -256,7 +254,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testKt2589() {
loadFile("regressions/kt2589.kt");
final Class aClass = loadClass("Foo", generateClassesInFile());
final Class aClass = generateClass("Foo");
assertTrue((aClass.getModifiers() & Opcodes.ACC_FINAL) == 0);
try {
@@ -284,7 +282,7 @@ public class PropertyGenTest extends CodegenTestCase {
public void testKt2677() {
loadFile("regressions/kt2677.kt");
final Class aClass = loadClass("DerivedWeatherReport", generateClassesInFile());
final Class aClass = generateClass("DerivedWeatherReport");
final Class bClass = aClass.getSuperclass();
try {
compiler/tests/org/jetbrains/jet/codegen/ScriptGenTest.java
+7 -8
View File
@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.asm4.Opcodes;
import org.jetbrains.asm4.Type;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.lang.parsing.JetScriptDefinition;
import org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
@@ -52,16 +51,16 @@ public class ScriptGenTest extends CodegenTestCase {
private void blackBoxScript(String filename) {
loadFile(filename);
GenerationState state = generateClassesInFileGetState();
ClassFileFactory factory = generateClassesInFile();
GeneratedClassLoader loader = createClassLoader(state.getFactory(), false);
GeneratedClassLoader loader = createClassLoader(factory);
String scriptClassName = ScriptNameUtil.classNameForScript(myFiles.getPsiFile());
try {
Class<?> scriptClass = loader.loadClass(scriptClassName);
Constructor constructor = getConstructor(scriptClass, state.getScriptCodegen().getScriptConstructorMethod());
Constructor constructor = getConstructor(scriptClass, factory.getState().getScriptCodegen().getScriptConstructorMethod());
scriptInstance = constructor.newInstance(myFiles.getScriptParameterValues().toArray());
assertFalse("expecting at least one expectation", myFiles.getExpectedValues().isEmpty());
@@ -189,7 +188,7 @@ public class ScriptGenTest extends CodegenTestCase {
public void testLanguage() {
JetScriptDefinitionProvider.getInstance(myEnvironment.getProject()).addScriptDefinition(FIB_SCRIPT_DEFINITION);
loadFile("script/fib.lang.kt");
final Class aClass = loadClass("Fib", generateClassesInFile());
final Class aClass = generateClass("Fib");
try {
Constructor constructor = aClass.getConstructor(int.class);
Field result = aClass.getDeclaredField("result");
@@ -205,7 +204,7 @@ public class ScriptGenTest extends CodegenTestCase {
public void testLanguageWithPackage() {
JetScriptDefinitionProvider.getInstance(myEnvironment.getProject()).addScriptDefinition(FIB_SCRIPT_DEFINITION);
loadFile("script/fibwp.lang.kt");
final Class aClass = loadClass("test.Fibwp", generateClassesInFile());
final Class aClass = generateClass("test.Fibwp");
try {
Constructor constructor = aClass.getConstructor(int.class);
Field result = aClass.getDeclaredField("result");
@@ -221,7 +220,7 @@ public class ScriptGenTest extends CodegenTestCase {
public void testDependentScripts() {
JetScriptDefinitionProvider.getInstance(myEnvironment.getProject()).addScriptDefinition(FIB_SCRIPT_DEFINITION);
loadFiles("script/fibwp.lang.kt", "script/fibwprunner.ktscript");
final Class aClass = loadClass("Fibwprunner", generateClassesInFile());
final Class aClass = generateClass("Fibwprunner");
try {
Constructor constructor = aClass.getConstructor();
Field result = aClass.getDeclaredField("result");
@@ -244,7 +243,7 @@ public class ScriptGenTest extends CodegenTestCase {
public void testScriptWhereMethodHasClosure() {
JetScriptDefinitionProvider.getInstance(myEnvironment.getProject()).addScriptDefinition(FIB_SCRIPT_DEFINITION);
loadFile("script/methodWithClosure.lang.kt");
final Class aClass = loadClass("MethodWithClosure", generateClassesInFile());
final Class aClass = generateClass("MethodWithClosure");
try {
Constructor constructor = aClass.getConstructor(int.class);
Object script = constructor.newInstance(239);
compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java
-4
View File
@@ -362,10 +362,6 @@ public class StdlibTest extends CodegenTestCase {
blackBoxFile("jdk-annotations/collections.kt");
}
public void testNoClassObjectForJavaClass() throws Exception {
blackBoxFileWithJava("stdlib/noClassObjectForJavaClass.kt");
}
public void testKt1076() {
blackBoxFile("regressions/kt1076.kt");
}
compiler/tests/org/jetbrains/jet/codegen/defaultConstructor/AbstractDefaultConstructorCodegenTest.java
+1 -3
View File
@@ -18,7 +18,6 @@ package org.jetbrains.jet.codegen.defaultConstructor;
import com.intellij.openapi.util.io.FileUtil;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.codegen.ClassFileFactory;
import org.jetbrains.jet.codegen.CodegenTestCase;
import java.io.File;
@@ -38,13 +37,12 @@ public abstract class AbstractDefaultConstructorCodegenTest extends CodegenTestC
protected void doTest(String path) throws IOException {
loadFileByFullPath(path);
ClassFileFactory codegens = generateClassesInFile();
String fileText = FileUtil.loadFile(new File(path));
String className = loadInstructionValue(fileText, "CLASS");
boolean hasDefaultConstructor = loadInstructionValue(fileText, "HAS_DEFAULT_CONSTRUCTOR").equals("true");
Class aClass = loadClass(className, codegens);
Class aClass = generateClass(className);
assertNotNull("Cannot find class with name " + className, aClass);
try {
Constructor constructor = aClass.getDeclaredConstructor();