Extract classPathInTheSameClassLoader into a separate test

- 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

compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java

@@ -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 = generateClass("Foo");
-        final Class aClass = loadClass("Foo", codegens);
         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

@@ -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

@@ -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);
+        blackBoxMultiFile(filename);
-    }
-
-    private void blackBoxFile(String filename, boolean classPathInTheSameClassLoader) {
-        loadFile(filename);
-        blackBox(classPathInTheSameClassLoader);
     }
 
     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) {
+    protected GeneratedClassLoader createClassLoader(ClassFileFactory factory) {
-        return createClassLoader(codegens, false);
-    }
-
-    protected GeneratedClassLoader createClassLoader(ClassFileFactory codegens, boolean classPathInTheSameClassLoader) {
         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()]);
+        return 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;
     }
 
     protected String generateToText() {
@@ -258,55 +241,34 @@ public abstract class CodegenTestCase extends UsefulTestCase {
     }
 
     protected Class generateNamespaceClass() {
-        ClassFileFactory state = generateClassesInFile();
+        String name = NamespaceCodegen.getJVMClassNameForKotlinNs(JetPsiUtil.getFQName(myFiles.getPsiFile())).getFqName().getFqName();
-        return loadRootNamespaceClass(state);
+        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();
+            fail("No class file was generated for: " + name);
-        }
-        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);
             return null;
         }
     }
 
     @NotNull
     protected ClassFileFactory generateClassesInFile() {
-        return generateClassesInFileGetState().getFactory();
+        if (alreadyGenerated == null) {
-    }
+            try {
-
-    @NotNull
-    protected GenerationState generateClassesInFileGetState() {
-        try {
-            if (alreadyGenerated == null) {
                 alreadyGenerated = generateCommon(myEnvironment, myFiles);
-            }
 
-            if (DxChecker.RUN_DX_CHECKER) {
+                if (DxChecker.RUN_DX_CHECKER) {
-                DxChecker.check(alreadyGenerated.getFactory());
+                    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

@@ -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

@@ -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 = generateClass("Foo");
-        final Class aClass = loadClass("Foo", codegens);
         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 = generateClass("Foo");
-        final Class aClass = loadClass("Foo", codegens);
         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

@@ -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

@@ -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

@@ -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();