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

More accurate environment management in tests

Browse Source
This commit is contained in:
Andrey Breslav
2012-07-09 13:38:35 +04:00
parent 7f6222cc4e
commit 4b062cb4e0
7 changed files with 76 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java
+3 -3
View File
@@ -46,13 +46,13 @@ public class AbstractLazyResolveDescriptorRendererTest extends AbstractLazyResol
protected void doTest(@NotNull String testFile) throws IOException {
InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer();
InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(regularEnvironment);
JetFile psiFile = JetPsiFactory.createFile(project, FileUtil.loadFile(new File(testFile), true));
JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
Collection<JetFile> files = Lists.newArrayList(psiFile);
ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
final ResolveSession resolveSession = new ResolveSession(project, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
final ResolveSession resolveSession = new ResolveSession(getProject(), lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
new FileBasedDeclarationProviderFactory(files));
final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java
+31 -15
View File
@@ -20,9 +20,11 @@ import com.google.common.base.Predicate;
import com.intellij.openapi.util.Pair;
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;
@@ -48,7 +50,7 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
.createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true), new JetTestUtils.TestFileFactory<JetFile>() {
@Override
public JetFile create(String fileName, String text) {
return JetPsiFactory.createFile(project, fileName, text);
return JetPsiFactory.createFile(getProject(), fileName, text);
}
});
@@ -64,21 +66,15 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
doTestForGivenFiles(transform, includeMembersOfObject, files, filterJetNamespace, serializeResultsTo);
}
protected void doTestForGivenFiles(Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>> transform,
protected void doTestForGivenFiles(
Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>> transform,
boolean includeMembersOfObject,
List<JetFile> files,
Predicate<NamespaceDescriptor> filterJetNamespace,
File serializeResultsTo) {
ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
InjectorForTopDownAnalyzer injector = createInjectorForTDA(module);
InjectorForTopDownAnalyzer tdaInjectorForLazy = getEagerInjectorForTopDownAnalyzer();
ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
ResolveSession
session = new ResolveSession(project, lazyModule, tdaInjectorForLazy.getModuleConfiguration(), new FileBasedDeclarationProviderFactory(files));
injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
File serializeResultsTo
) {
ModuleDescriptor module = resolveEagerly(files, ConfigurationKind.JDK_ONLY);
ModuleDescriptor lazyModule = resolveLazily(files, ConfigurationKind.JDK_ONLY);
Pair<NamespaceDescriptor, NamespaceDescriptor> namespacesToCompare = transform.fun(Pair.create(module, lazyModule));
@@ -86,6 +82,23 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
includeMembersOfObject, filterJetNamespace, serializeResultsTo);
}
private ModuleDescriptor resolveLazily(List<JetFile> files, ConfigurationKind configurationKind) {
ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration();
ResolveSession
session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files));
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
@@ -105,8 +118,11 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
public Pair<NamespaceDescriptor, NamespaceDescriptor> fun(Pair<ModuleDescriptor, ModuleDescriptor> pair) {
ModuleDescriptor expectedModule = pair.first;
ModuleDescriptor actualModule = pair.second;
NamespaceDescriptor actual = theOnlySubPackage(actualModule.getRootNamespace());
NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(actual.getName());
Name test = Name.identifier("test");
NamespaceDescriptor actual = actualModule.getRootNamespace().getMemberScope().getNamespace(test);
NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(test);
//NamespaceDescriptor actual = theOnlySubPackage(actualModule.getRootNamespace());
//NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(actual.getName());
return Pair.create(expected, actual);
}
}, includeMembersOfObject);
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java
+25 -10
View File
@@ -21,8 +21,9 @@ import com.intellij.openapi.Disposable;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Disposer;
import com.intellij.psi.PsiFile;
import org.jetbrains.jet.CompileCompilerDependenciesTest;
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.di.InjectorForTopDownAnalyzer;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
@@ -42,16 +43,30 @@ import java.util.Collections;
* @author abreslav
*/
public abstract class AbstractLazyResolveTest {
private final Disposable rootDisposable = new Disposable() {
@Override
public void dispose() {
}
};
protected final JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(rootDisposable,
CompileCompilerDependenciesTest.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, true)
);
protected final Project project = jetCoreEnvironment.getProject();
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 final JetCoreEnvironmentWithDisposable regularEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.ALL);
protected Project getProject() {
return regularEnvironment.project;
}
@BeforeClass
public static void setUp() throws Exception {
@@ -63,20 +78,20 @@ public abstract class AbstractLazyResolveTest {
Disposer.dispose(rootDisposable);
}
protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer() {
protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) {
ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("<eager module for lazy>"));
InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy);
InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment);
// This line is required fro the 'jet' namespace to be filled in with functions
tdaInjectorForLazy.getTopDownAnalyzer().analyzeFiles(
Collections.singletonList(JetPsiFactory.createFile(project, "")), Collections.<AnalyzerScriptParameter>emptyList());
Collections.singletonList(JetPsiFactory.createFile(getProject(), "")), Collections.<AnalyzerScriptParameter>emptyList());
return tdaInjectorForLazy;
}
protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module) {
protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironmentWithDisposable environment) {
TopDownAnalysisParameters params = new TopDownAnalysisParameters(
Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
return new InjectorForTopDownAnalyzerForJvm(project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
return new InjectorForTopDownAnalyzerForJvm(environment.project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java
+3 -3
View File
@@ -62,7 +62,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
ResolveSession session = new ResolveSession(
project,
getProject(),
lazyModule,
new SpecialModuleConfiguration(),
new FileBasedDeclarationProviderFactory(files),
@@ -88,7 +88,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
private void addJetFilesFromDir(List<JetFile> files, File jetDir) throws IOException {
for (File file : jetDir.listFiles()) {
if (FileUtil.getExtension(file.getName()).equals("jet")) {
files.add(JetPsiFactory.createFile(project, file.getName(), FileUtil.loadFile(file, true)));
files.add(JetPsiFactory.createFile(getProject(), file.getName(), FileUtil.loadFile(file, true)));
}
}
}
@@ -97,7 +97,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
@Override
public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) {
directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport));
directives.add(JetPsiFactory.createImportDirective(getProject(), defaultJetImport));
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveDescriptorRendererTestGenerated.java
+2 -2
View File
@@ -34,7 +34,7 @@ import java.util.Set;
public class LazyResolveDescriptorRendererTestGenerated {
public static class Renderer extends AbstractLazyResolveDescriptorRendererTest {
@Test
public void allTestsPresentInRenderer() throws Exception {
public void testAllFilesPresentInRenderer() throws Exception {
allTestsPresent(Renderer.class, new File("compiler/testData/renderer"), true);
}
@@ -103,7 +103,7 @@ public class LazyResolveDescriptorRendererTestGenerated {
public static class DescriptorRenderer extends AbstractLazyResolveDescriptorRendererTest {
@Test
public void allTestsPresentInDescriptorRenderer() throws Exception {
public void testAllFilesPresentInDescriptorRenderer() throws Exception {
allTestsPresent(DescriptorRenderer.class, new File("compiler/testData/lazyResolve/descriptorRenderer"), true);
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
+11 -11
View File
@@ -30,12 +30,12 @@ import java.util.Set;
@Suite.SuiteClasses({
LazyResolveNamespaceComparingTestGenerated.ReadKotlinBinaryClass.class,
LazyResolveNamespaceComparingTestGenerated.ReadJavaBinaryClass.class,
LazyResolveNamespaceComparingTestGenerated.LazyResolve.class
LazyResolveNamespaceComparingTestGenerated.NamespaceComparator.class
})
public class LazyResolveNamespaceComparingTestGenerated {
public static class ReadKotlinBinaryClass extends AbstractLazyResolveNamespaceComparingTest {
@Test
public void allTestsPresentInReadKotlinBinaryClass() throws Exception {
public void testAllFilesPresentInReadKotlinBinaryClass() throws Exception {
allTestsPresent(ReadKotlinBinaryClass.class, new File("compiler/testData/readKotlinBinaryClass"), true);
}
@@ -769,7 +769,7 @@ public class LazyResolveNamespaceComparingTestGenerated {
public static class ReadJavaBinaryClass extends AbstractLazyResolveNamespaceComparingTest {
@Test
public void allTestsPresentInReadJavaBinaryClass() throws Exception {
public void testAllFilesPresentInReadJavaBinaryClass() throws Exception {
allTestsPresent(ReadJavaBinaryClass.class, new File("compiler/testData/readJavaBinaryClass"), true);
}
@@ -1048,6 +1048,11 @@ public class LazyResolveNamespaceComparingTestGenerated {
doTestSinglePackage("compiler/testData/readJavaBinaryClass/MethosWithPRefTP.kt");
}
@Test
public void testModalityOfFakeOverrides() throws Exception {
doTestSinglePackage("compiler/testData/readJavaBinaryClass/modality/ModalityOfFakeOverrides.kt");
}
@Test
public void testMyException() throws Exception {
doTestSinglePackage("compiler/testData/readJavaBinaryClass/MyException.kt");
@@ -1111,15 +1116,10 @@ public class LazyResolveNamespaceComparingTestGenerated {
}
}
public static class LazyResolve extends AbstractLazyResolveNamespaceComparingTest {
public static class NamespaceComparator extends AbstractLazyResolveNamespaceComparingTest {
@Test
public void allTestsPresentInLazyResolve() throws Exception {
allTestsPresent(LazyResolve.class, new File("compiler/testData/lazyResolve"), true);
}
@Test
public void testClassObject() throws Exception {
doTest("compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt");
public void testAllFilesPresentInNamespaceComparator() throws Exception {
allTestsPresent(NamespaceComparator.class, new File("compiler/testData/lazyResolve/namespaceComparator"), true);
}
@Test
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestGenerator.java
+1 -1
View File
@@ -75,7 +75,7 @@ public class LazyResolveTestGenerator {
true,
TestGenerator.filterFilesByExtension(TEST_DATA_FILE_EXTENSION),
"doTestSinglePackage"),
new TestDataSource(new File("compiler/testData/lazyResolve"),
new TestDataSource(new File("compiler/testData/lazyResolve/namespaceComparator"),
true,
TestGenerator.filterFilesByExtension(TEST_DATA_FILE_EXTENSION),
"doTest")