diff --git a/compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java b/compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java new file mode 100644 index 00000000000..35e74271a9c --- /dev/null +++ b/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; + } +} diff --git a/compiler/tests/org/jetbrains/jet/KotlinTestWithEnvironmentManagement.java b/compiler/tests/org/jetbrains/jet/KotlinTestWithEnvironmentManagement.java new file mode 100644 index 00000000000..44049f80df0 --- /dev/null +++ b/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(); + } + +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 91f4789a333..b9625c270b5 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/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 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(); + } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java index 12a9801c64e..9960fe832a8 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/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 files = JetTestUtils - .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true), new JetTestUtils.TestFileFactory() { - @Override - public JetFile create(String fileName, String text) { - return JetPsiFactory.createFile(getProject(), fileName, text); - } - }); + .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true), + new JetTestUtils.TestFileFactory() { + @Override + public JetFile create(String fileName, String text) { + return JetPsiFactory.createFile(getProject(), fileName, text); + } + }); Predicate filterJetNamespace = new Predicate() { @Override @@ -91,14 +92,6 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract return lazyModule; } - protected ModuleDescriptor resolveEagerly(List files, ConfigurationKind configurationKind) { - ModuleDescriptor module = new ModuleDescriptor(Name.special("")); - JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind); - InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment); - injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); - return module; - } - protected void doTest(String testFileName) throws Exception { doTest(testFileName, new Function, Pair>() { @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(); + } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java index 38a1ffd01d2..125506d7d28 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java +++ b/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.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.KotlinTestWithDefaultEnvironment; 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 { - - 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); - } +public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvironment { protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) { ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("")); @@ -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 files, ConfigurationKind configurationKind) { + ModuleDescriptor module = new ModuleDescriptor(Name.special("")); + JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind); + InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment); + injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); + return module; + } + }