New base classes for lazy resolve tests + generators in main methods

compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2012 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;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author abreslav
+ */
+public abstract class KotlinTestWithDefaultEnvironment extends KotlinTestWithEnvironmentManagement {
+    private JetCoreEnvironmentWithDisposable regularEnvironment;
+
+    @NotNull
+    public JetCoreEnvironmentWithDisposable getRegularEnvironment() {
+        if (regularEnvironment == null) {
+            regularEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.ALL);
+        }
+        return regularEnvironment;
+    }
+
+    @NotNull
+    protected Project getProject() {
+        return getRegularEnvironment().project;
+    }
+}

compiler/tests/org/jetbrains/jet/KotlinTestWithEnvironmentManagement.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010-2012 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;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
+import junit.framework.TestCase;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+
+/**
+ * @author abreslav
+ */
+public abstract class KotlinTestWithEnvironmentManagement extends TestCase {
+    static {
+        System.setProperty("java.awt.headless", "true");
+    }
+
+    private final Disposable rootDisposable = new Disposable() {
+        @Override
+        public void dispose() {
+        }
+    };
+
+    public class JetCoreEnvironmentWithDisposable {
+        public final JetCoreEnvironment jetCoreEnvironment;
+
+        public final Project project;
+
+        public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind) {
+            this.jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(rootDisposable, configurationKind);
+            this.project = jetCoreEnvironment.getProject();
+        }
+
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        Disposer.dispose(rootDisposable);
+        super.tearDown();
+    }
+
+}

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -29,10 +29,13 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
+import org.jetbrains.jet.test.generator.SimpleTestClassModel;
+import org.jetbrains.jet.test.generator.TestGenerator;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
@@ -44,7 +47,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends Abstract
 
     protected void doTest(@NotNull String testFile) throws IOException {
 
-        InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(regularEnvironment);
+        InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment());
 
         JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
         Collection<JetFile> files = Lists.newArrayList(psiFile);
@@ -136,4 +139,25 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends Abstract
         Document document = new DocumentImpl(psiFile.getText());
         assertEquals(JetTestUtils.getLastCommentedLines(document), renderedDescriptors.toString());
     }
+
+    public static void main(String[] args) throws IOException {
+        String extension = "kt";
+        new TestGenerator(
+            "compiler/tests/",
+            AbstractLazyResolveDescriptorRendererTest.class.getPackage().getName(),
+            "LazyResolveDescriptorRendererTestGenerated",
+            AbstractLazyResolveDescriptorRendererTest.class,
+            Arrays.asList(
+                    new SimpleTestClassModel(new File("compiler/testData/renderer"),
+                                             true,
+                                             extension,
+                                             "doTest"),
+                    new SimpleTestClassModel(new File("compiler/testData/lazyResolve/descriptorRenderer"),
+                                             true,
+                                             extension,
+                                             "doTest")
+            ),
+            LazyResolveTestGenerator.class
+        ).generateAndSave();
+    }
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java

@@ -22,19 +22,19 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.Function;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.jvm.compiler.NamespaceComparator;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
-import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.test.generator.SimpleTestClassModel;
+import org.jetbrains.jet.test.generator.TestGenerator;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.List;
 
 /**
@@ -47,12 +47,13 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
             boolean includeMembersOfObject
     ) throws IOException {
         List<JetFile> files = JetTestUtils
-                .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true), new JetTestUtils.TestFileFactory<JetFile>() {
+                .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true),
-                    @Override
+                                 new JetTestUtils.TestFileFactory<JetFile>() {
-                    public JetFile create(String fileName, String text) {
+                                     @Override
-                        return JetPsiFactory.createFile(getProject(), fileName, text);
+                                     public JetFile create(String fileName, String text) {
-                    }
+                                         return JetPsiFactory.createFile(getProject(), fileName, text);
-                });
+                                     }
+                                 });
 
         Predicate<NamespaceDescriptor> filterJetNamespace = new Predicate<NamespaceDescriptor>() {
             @Override
@@ -91,14 +92,6 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
         return lazyModule;
     }
 
-    protected ModuleDescriptor resolveEagerly(List<JetFile> files, ConfigurationKind configurationKind) {
-        ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
-        JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
-        InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
-        injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
-        return module;
-    }
-
     protected void doTest(String testFileName) throws Exception {
         doTest(testFileName, new Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>>() {
             @Override
@@ -131,4 +124,29 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
     private NamespaceDescriptor theOnlySubPackage(NamespaceDescriptor namespace) {
         return (NamespaceDescriptor) namespace.getMemberScope().getAllDescriptors().iterator().next();
     }
+
+    public static void main(String[] args) throws IOException {
+        String extension = "kt";
+        new TestGenerator(
+            "compiler/tests/",
+            AbstractLazyResolveNamespaceComparingTest.class.getPackage().getName(),
+            "LazyResolveNamespaceComparingTestGenerated",
+            AbstractLazyResolveNamespaceComparingTest.class,
+            Arrays.asList(
+                    new SimpleTestClassModel(new File("compiler/testData/readKotlinBinaryClass"),
+                                             true,
+                                             extension,
+                                             "doTestSinglePackage"),
+                    new SimpleTestClassModel(new File("compiler/testData/readJavaBinaryClass"),
+                                             true,
+                                             extension,
+                                             "doTestSinglePackage"),
+                    new SimpleTestClassModel(new File("compiler/testData/lazyResolve/namespaceComparator"),
+                                             true,
+                                             extension,
+                                             "doTest")
+            ),
+            LazyResolveTestGenerator.class
+        ).generateAndSave();
+    }
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java

@@ -17,19 +17,14 @@
 package org.jetbrains.jet.lang.resolve.lazy;
 
 import com.google.common.base.Predicates;
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Disposer;
 import com.intellij.psi.PsiFile;
-import junit.framework.TestCase;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
-import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.KotlinTestWithDefaultEnvironment;
-import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -37,51 +32,12 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
 import java.util.Collections;
+import java.util.List;
 
 /**
  * @author abreslav
  */
-public abstract class AbstractLazyResolveTest extends TestCase {
+public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvironment {
-
-    static {
-        System.setProperty("java.awt.headless", "true");
-    }
-
-    private final Disposable rootDisposable = new Disposable() {
-        @Override
-        public void dispose() {
-        }
-    };
-
-    public class JetCoreEnvironmentWithDisposable {
-        public final JetCoreEnvironment jetCoreEnvironment;
-
-        public final Project project;
-
-        public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind) {
-            this.jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(rootDisposable, configurationKind);
-            this.project = jetCoreEnvironment.getProject();
-        }
-
-    }
-
-    protected JetCoreEnvironmentWithDisposable regularEnvironment;
-
-    protected Project getProject() {
-        return regularEnvironment.project;
-    }
-
-
-    @Override
-    protected void setUp() throws Exception {
-        super.setUp();
-        regularEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.ALL);
-    }
-
-    @Override
-    public void tearDown() throws Exception {
-        Disposer.dispose(rootDisposable);
-    }
 
     protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) {
         ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("<eager module for lazy>"));
@@ -99,4 +55,12 @@ public abstract class AbstractLazyResolveTest extends TestCase {
         return new InjectorForTopDownAnalyzerForJvm(environment.project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
     }
 
+    protected ModuleDescriptor resolveEagerly(List<JetFile> files, ConfigurationKind configurationKind) {
+        ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
+        JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
+        InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
+        injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
+        return module;
+    }
+
 }