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

Refactor some of the tests for loading descriptors.

Browse Source 
Move most of the logic to LoadDescriptorUtil and refactor to avoid duplication.
More descriptive names for LoadDescriptorUtil methods.
Minor code improvements.
This commit is contained in:
Pavel V. Talanov
2012-08-23 12:38:08 +04:00
parent 4457c7b6ba
commit f3dd54e70f
6 changed files with 134 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java
+1 -1
View File
@@ -58,7 +58,7 @@ public class GenerationUtils {
@NotNull @NotNull
private static GenerationState compileFilesGetGenerationState(@NotNull AnalyzeExhaust analyzeExhaust, @NotNull List<JetFile> files) { public static GenerationState compileFilesGetGenerationState(@NotNull AnalyzeExhaust analyzeExhaust, @NotNull List<JetFile> files) {
analyzeExhaust.throwIfError(); analyzeExhaust.throwIfError();
GenerationState state = new GenerationState(ClassBuilderFactories.TEST, analyzeExhaust, files); GenerationState state = new GenerationState(ClassBuilderFactories.TEST, analyzeExhaust, files);
state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java
+9 -28
View File
@@ -16,23 +16,11 @@
package org.jetbrains.jet.jvm.compiler; package org.jetbrains.jet.jvm.compiler;
import com.intellij.openapi.util.io.FileUtil;
import org.jetbrains.annotations.NotNull; 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.lang.BuiltinsScopeExtensionMode;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.jetbrains.jet.test.TestCaseWithTmpdir;
import org.jetbrains.jet.test.generator.SimpleTestClassModel; import org.jetbrains.jet.test.generator.SimpleTestClassModel;
import org.jetbrains.jet.test.generator.TestGenerator; import org.jetbrains.jet.test.generator.TestGenerator;
import org.jetbrains.jet.test.util.NamespaceComparator;
import org.junit.Assert; import org.junit.Assert;
import java.io.File; import java.io.File;
@@ -40,6 +28,11 @@ import java.io.IOException;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.analyzeKotlinAndExtractTestNamespace;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndExtractTestNamespaceFromBinary;
import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces;
/** /**
* @author Stepan Koltsov * @author Stepan Koltsov
*/ */
@@ -50,22 +43,10 @@ public abstract class AbstractReadJavaBinaryClassTest extends TestCaseWithTmpdir
File javaFile = new File(javaFileName); File javaFile = new File(javaFileName);
File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt")); File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt"));
File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt")); File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt"));
NamespaceDescriptor nsa = analyzeKotlin(ktFile); NamespaceDescriptor nsa = analyzeKotlinAndExtractTestNamespace(ktFile, myTestRootDisposable);
NamespaceDescriptor nsb = LoadDescriptorUtil.compileJava(Collections.singletonList(javaFile), tmpdir, myTestRootDisposable); NamespaceDescriptor nsb = compileJavaAndExtractTestNamespaceFromBinary(Collections.singletonList(javaFile),
NamespaceComparator.compareNamespaces(nsa, nsb, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); tmpdir, myTestRootDisposable);
} compareNamespaces(nsa, nsb, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
@NotNull
private NamespaceDescriptor analyzeKotlin(File ktFile) throws Exception {
JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY);
String text = FileUtil.loadFile(ktFile);
JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject());
BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
psiFile, Collections.<AnalyzerScriptParameter>emptyList(), BuiltinsScopeExtensionMode.ALL).getBindingContext();
return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel(Name.identifier("test")));
} }
public static void main(String[] args) throws IOException { public static void main(String[] args) throws IOException {
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java
+94 -27
View File
@@ -24,18 +24,21 @@ import org.jetbrains.jet.CompileCompilerDependenciesTest;
import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.ClassFileFactory;
import org.jetbrains.jet.codegen.GenerationState; import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.GenerationUtils;
import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile; 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.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -46,43 +49,76 @@ import javax.tools.*;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.Charset; import java.nio.charset.Charset;
import java.util.Arrays; import java.util.*;
import java.util.Collection;
import java.util.List; import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations;
import java.util.Locale; import static org.jetbrains.jet.lang.psi.JetPsiFactory.createFile;
/** /**
* @author Pavel Talanov * @author Pavel Talanov
*/ */
public final class LoadDescriptorUtil { public final class LoadDescriptorUtil {
@NotNull
public static final FqName TEST_PACKAGE_FQNAME = FqName.topLevel(Name.identifier("test"));
private LoadDescriptorUtil() { private LoadDescriptorUtil() {
} }
@NotNull @NotNull
public static NamespaceDescriptor compileKotlin(@NotNull File kotlinFile, File tmpdir, Disposable disposable) public static NamespaceDescriptor compileKotlinAndExtractTestNamespaceDescriptorFromBinary(
@NotNull File kotlinFile,
@NotNull File outDir,
@NotNull Disposable disposable
)
throws IOException { throws IOException {
JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.JDK_ONLY); compileKotlinToDirAndGetAnalyzeExhaust(kotlinFile, outDir, disposable);
JetFile psiFile = JetPsiFactory.createFile(jetCoreEnvironment.getProject(), FileUtil.loadFile(kotlinFile, true)); return extractTestNamespaceFromBinaries(outDir, disposable);
GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile); }
@NotNull
public static AnalyzeExhaust compileKotlinToDirAndGetAnalyzeExhaust(
@NotNull File kotlinFile,
@NotNull File outDir,
@NotNull Disposable disposable
) throws IOException {
JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(kotlinFile, disposable);
GenerationState state = GenerationUtils.compileFilesGetGenerationState(fileAndExhaust.getExhaust(), Collections.singletonList(
fileAndExhaust.getJetFile()));
ClassFileFactory classFileFactory = state.getFactory(); ClassFileFactory classFileFactory = state.getFactory();
CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, tmpdir); CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, outDir);
NamespaceDescriptor namespaceFromSource = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, psiFile); return fileAndExhaust.getExhaust();
Assert.assertEquals("test", namespaceFromSource.getName().getName()); }
@NotNull
public static NamespaceDescriptor extractTestNamespaceFromBinaries(@NotNull File outDir, @NotNull Disposable disposable) {
Disposer.dispose(disposable); Disposer.dispose(disposable);
jetCoreEnvironment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerConfigurationForTests( CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(
ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir, ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), outDir,
ForTestCompileRuntime.runtimeJarForTests())); ForTestCompileRuntime.runtimeJarForTests());
JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, configuration);
InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL, InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL,
jetCoreEnvironment.getProject()); jetCoreEnvironment.getProject());
JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
return javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); NamespaceDescriptor namespaceDescriptor =
javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
assert namespaceDescriptor != null;
return namespaceDescriptor;
} }
@NotNull @NotNull
public static NamespaceDescriptor compileJava(@NotNull Collection<File> javaFiles, File tmpdir, Disposable disposable) public static NamespaceDescriptor compileJavaAndExtractTestNamespaceFromBinary(
@NotNull Collection<File> javaFiles,
@NotNull File outDir,
@NotNull Disposable disposable
)
throws IOException { throws IOException {
compileJavaToDir(javaFiles, outDir);
return extractTestNamespaceFromBinaries(outDir, disposable);
}
private static void compileJavaToDir(@NotNull Collection<File> javaFiles, @NotNull File ourDir) throws IOException {
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, Locale.ENGLISH, Charset.forName("utf-8")); StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, Locale.ENGLISH, Charset.forName("utf-8"));
@@ -90,7 +126,7 @@ public final class LoadDescriptorUtil {
Iterable<? extends JavaFileObject> javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(javaFiles); Iterable<? extends JavaFileObject> javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(javaFiles);
List<String> options = Arrays.asList( List<String> options = Arrays.asList(
"-classpath", "out/production/runtime" + File.pathSeparator + JetTestUtils.getAnnotationsJar().getPath(), "-classpath", "out/production/runtime" + File.pathSeparator + JetTestUtils.getAnnotationsJar().getPath(),
"-d", tmpdir.getPath() "-d", ourDir.getPath()
); );
JavaCompiler.CompilationTask task = javaCompiler.getTask(null, fileManager, null, options, null, javaFileObjectsFromFiles); JavaCompiler.CompilationTask task = javaCompiler.getTask(null, fileManager, null, options, null, javaFileObjectsFromFiles);
@@ -99,14 +135,45 @@ public final class LoadDescriptorUtil {
finally { finally {
fileManager.close(); fileManager.close();
} }
}
JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest. @NotNull
compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir, public static NamespaceDescriptor analyzeKotlinAndExtractTestNamespace(@NotNull File ktFile, @NotNull Disposable disposable) throws Exception {
new File("out/production/runtime"))); JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(ktFile, disposable);
//noinspection ConstantConditions
return fileAndExhaust.getExhaust().getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME);
}
InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL, private static class JetFileAndExhaust {
jetCoreEnvironment.getProject());
JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); @NotNull
return javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); public static JetFileAndExhaust createJetFileAndAnalyze(@NotNull File kotlinFile, @NotNull Disposable disposable)
throws IOException {
JetCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.JDK_ONLY);
JetFile jetFile = createFile(jetCoreEnvironment.getProject(), FileUtil.loadFile(kotlinFile, true));
AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors(
jetFile, Collections.<AnalyzerScriptParameter>emptyList(), BuiltinsScopeExtensionMode.ALL);
return new JetFileAndExhaust(jetFile, exhaust);
}
@NotNull
private final JetFile jetFile;
@NotNull
private final AnalyzeExhaust exhaust;
private JetFileAndExhaust(@NotNull JetFile file, @NotNull AnalyzeExhaust exhaust) {
jetFile = file;
this.exhaust = exhaust;
}
@NotNull
public JetFile getJetFile() {
return jetFile;
}
@NotNull
public AnalyzeExhaust getExhaust() {
return exhaust;
}
} }
} }
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorsTest.java
+4 -2
View File
@@ -30,12 +30,14 @@ import java.io.File;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndExtractTestNamespaceFromBinary;
/** /**
* @author Pavel Talanov * @author Pavel Talanov
*/ */
public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment { public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment {
@NotNull @NotNull
private final String PATH = "compiler/testData/loadJavaDescriptors"; private static final String PATH = "compiler/testData/loadJavaDescriptors";
@Override @Override
protected JetCoreEnvironment createEnvironment() { protected JetCoreEnvironment createEnvironment() {
@@ -51,7 +53,7 @@ public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment {
}); });
File expected = new File(expectedFileName); File expected = new File(expectedFileName);
File tmpDir = JetTestUtils.tmpDir(expected.getName()); File tmpDir = JetTestUtils.tmpDir(expected.getName());
NamespaceDescriptor javaNamespaceDescriptor = LoadDescriptorUtil.compileJava(files, tmpDir, getTestRootDisposable()); NamespaceDescriptor javaNamespaceDescriptor = compileJavaAndExtractTestNamespaceFromBinary(files, tmpDir, getTestRootDisposable());
//NOTE: comparing namespace to file (hack) //NOTE: comparing namespace to file (hack)
NamespaceComparator.compareNamespaces(javaNamespaceDescriptor, javaNamespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expected); NamespaceComparator.compareNamespaces(javaNamespaceDescriptor, javaNamespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expected);
} }
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinDescriptorsTest.java
+8 -30
View File
@@ -16,50 +16,28 @@
package org.jetbrains.jet.jvm.compiler; package org.jetbrains.jet.jvm.compiler;
import com.google.common.base.Function;
import com.google.common.collect.Collections2;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.io.FileUtil;
import junit.framework.Assert;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.CompileCompilerDependenciesTest;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.codegen.ClassFileFactory;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.codegen.GenerationUtils;
import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; 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.BindingContext;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.jetbrains.jet.test.TestCaseWithTmpdir;
import org.jetbrains.jet.test.util.NamespaceComparator;
import java.io.File; import java.io.File;
import java.util.Arrays;
import java.util.Collection; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinAndExtractTestNamespaceDescriptorFromBinary;
import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces;
/** /**
* @author Pavel Talanov * @author Pavel Talanov
*/ */
public final class LoadKotlinDescriptorsTest extends TestCaseWithTmpdir { public final class LoadKotlinDescriptorsTest extends TestCaseWithTmpdir {
@NotNull @NotNull
private final String PATH = "compiler/testData/loadKotlinDescriptors"; private static final String PATH = "compiler/testData/loadKotlinDescriptors";
private void doTest(@NotNull String expectedFileName, @NotNull String kotlinFileName) throws Exception { private void doTest(@NotNull String expectedFileName, @NotNull String kotlinFileName) throws Exception {
NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.compileKotlin(new File(kotlinFileName), tmpdir, myTestRootDisposable); NamespaceDescriptor namespaceFromClass =
compileKotlinAndExtractTestNamespaceDescriptorFromBinary(new File(kotlinFileName), tmpdir, myTestRootDisposable);
NamespaceComparator.compareNamespaces(namespaceFromClass, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, new File(expectedFileName)); compareNamespaces(namespaceFromClass, namespaceFromClass, DONT_INCLUDE_METHODS_OF_OBJECT, new File(expectedFileName));
} }
public void testSimpleEnum() throws Exception { public void testSimpleEnum() throws Exception {
compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java
+18 -52
View File
@@ -16,49 +16,36 @@
package org.jetbrains.jet.jvm.compiler; package org.jetbrains.jet.jvm.compiler;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.CharsetToolkit;
import com.intellij.psi.PsiFileFactory;
import com.intellij.psi.impl.PsiFileFactoryImpl;
import com.intellij.testFramework.LightVirtualFile;
import junit.framework.Assert; import junit.framework.Assert;
import junit.framework.Test; import junit.framework.Test;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.*; import org.jetbrains.jet.JetTestCaseBuilder;
import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.codegen.ClassFileFactory;
import org.jetbrains.jet.codegen.GenerationState;
import org.jetbrains.jet.codegen.GenerationUtils;
import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.plugin.JetLanguage;
import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.jetbrains.jet.test.TestCaseWithTmpdir;
import org.jetbrains.jet.test.util.NamespaceComparator; import org.jetbrains.jet.test.util.NamespaceComparator;
import java.io.File; import java.io.File;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME;
import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalyzeExhaust;
import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces;
/** /**
* Compile Kotlin and then parse model from .class files. * Compile Kotlin and then parse model from .class files.
* *
* @author Stepan Koltsov * @author Stepan Koltsov
*/ */
public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { @SuppressWarnings("JUnitTestCaseWithNoTests")
public final class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
private JetCoreEnvironment jetCoreEnvironment;
@NotNull
private final File testFile; private final File testFile;
@NotNull
private final File txtFile; private final File txtFile;
@SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors")
public ReadKotlinBinaryClassTest(@NotNull File testFile) { public ReadKotlinBinaryClassTest(@NotNull File testFile) {
this.testFile = testFile; this.testFile = testFile;
this.txtFile = new File(testFile.getPath().replaceFirst("\\.kt$", ".txt")); this.txtFile = new File(testFile.getPath().replaceFirst("\\.kt$", ".txt"));
@@ -67,35 +54,14 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
@Override @Override
public void runTest() throws Exception { public void runTest() throws Exception {
jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY); AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(testFile, tmpdir, getTestRootDisposable());
String text = FileUtil.loadFile(testFile);
JetFile psiFile = JetTestUtils.createFile(testFile.getName(), text, jetCoreEnvironment.getProject());
GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile);
ClassFileFactory classFileFactory = state.getFactory();
CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, tmpdir);
NamespaceDescriptor namespaceFromSource = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, psiFile);
NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR,
TEST_PACKAGE_FQNAME);
assert namespaceFromSource != null;
Assert.assertEquals("test", namespaceFromSource.getName().getName()); Assert.assertEquals("test", namespaceFromSource.getName().getName());
NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.extractTestNamespaceFromBinaries(tmpdir, getTestRootDisposable());
Disposer.dispose(myTestRootDisposable); compareNamespaces(namespaceFromSource, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
jetCoreEnvironment = new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir,
ForTestCompileRuntime.runtimeJarForTests()));
InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL,
jetCoreEnvironment.getProject());
JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
} }
public static Test suite() { public static Test suite() {
@@ -107,5 +73,5 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
} }
}); });
} }
} }