Base class for multi-file tests extracted

This commit is contained in:
Andrey Breslav
2014-11-04 20:24:11 +02:00
parent f16dcdd8a9
commit 586b7e3dee
2 changed files with 140 additions and 83 deletions
@@ -18,12 +18,10 @@ package org.jetbrains.jet.checkers;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.io.Files;
import com.intellij.lang.java.JavaLanguage;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.Conditions;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiFileFactory;
import com.intellij.psi.search.GlobalSearchScope;
@@ -34,29 +32,22 @@ import kotlin.Function1;
import kotlin.KotlinPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.asJava.AsJavaPackage;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.lang.diagnostics.*;
import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.Diagnostics;
import org.jetbrains.jet.lang.types.Flexibility;
import org.jetbrains.jet.utils.UtilsPackage;
import org.junit.Assert;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public abstract class BaseDiagnosticsTest extends JetLiteFixture {
public abstract class BaseDiagnosticsTest extends
KotlinMultiFileTestWithWithJava<BaseDiagnosticsTest.TestModule, BaseDiagnosticsTest.TestFile> {
public static final String DIAGNOSTICS_DIRECTIVE = "DIAGNOSTICS";
public static final Pattern DIAGNOSTICS_PATTERN = Pattern.compile("([\\+\\-!])(\\w+)\\s*");
@@ -86,81 +77,17 @@ public abstract class BaseDiagnosticsTest extends JetLiteFixture {
private static final String EXPLICIT_FLEXIBLE_TYPES_IMPORT = "import " + EXPLICIT_FLEXIBLE_PACKAGE + "." + EXPLICIT_FLEXIBLE_CLASS_NAME;
@Override
protected JetCoreEnvironment createEnvironment() {
File javaFilesDir = createJavaFilesDir();
return JetCoreEnvironment.createForTests(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests(
ConfigurationKind.JDK_AND_ANNOTATIONS,
TestJdkKind.MOCK_JDK,
Arrays.asList(JetTestUtils.getAnnotationsJar()),
Arrays.asList(javaFilesDir)
));
protected TestModule createTestModule(String name) {
return new TestModule(name);
}
protected File createJavaFilesDir() {
File javaFilesDir = new File(FileUtil.getTempDirectory(), "java-files");
try {
JetTestUtils.mkdirs(javaFilesDir);
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
}
return javaFilesDir;
@Override
protected TestFile createTestFile(TestModule module, String fileName, String text, Map<String, String> directives) {
return new TestFile(module, fileName, text, directives);
}
private static boolean writeJavaFile(@NotNull String fileName, @NotNull String content, @NotNull File javaFilesDir) {
try {
File javaFile = new File(javaFilesDir, fileName);
JetTestUtils.mkdirs(javaFile.getParentFile());
Files.write(content, javaFile, Charset.forName("utf-8"));
return true;
} catch (Exception e) {
throw UtilsPackage.rethrow(e);
}
}
protected void doTest(String filePath) throws IOException {
File file = new File(filePath);
final File javaFilesDir = createJavaFilesDir();
String expectedText = JetTestUtils.doLoadFile(file);
class ModuleAndDependencies {
final TestModule module;
final List<String> dependencies;
ModuleAndDependencies(TestModule module, List<String> dependencies) {
this.module = module;
this.dependencies = dependencies;
}
}
final Map<String, ModuleAndDependencies> modules = new HashMap<String, ModuleAndDependencies>();
List<TestFile> testFiles =
JetTestUtils.createTestFiles(file.getName(), expectedText, new JetTestUtils.TestFileFactory<TestModule, TestFile>() {
@Override
public TestFile createFile(
@Nullable TestModule module,
@NotNull String fileName,
@NotNull String text,
@NotNull Map<String, String> directives
) {
if (fileName.endsWith(".java")) {
writeJavaFile(fileName, text, javaFilesDir);
}
return new TestFile(module, fileName, text, directives);
}
@Override
public TestModule createModule(@NotNull String name, @NotNull List<String> dependencies) {
TestModule module = new TestModule(name);
ModuleAndDependencies oldValue = modules.put(name, new ModuleAndDependencies(module, dependencies));
assert oldValue == null : "Module " + name + " declared more than once";
return module;
}
});
@Override
protected void doMultiFileTest(File file, final Map<String, ModuleAndDependencies> modules, List<TestFile> testFiles) {
for (final ModuleAndDependencies moduleAndDependencies : modules.values()) {
List<TestModule> dependencies = KotlinPackage.map(
moduleAndDependencies.dependencies,
@@ -168,7 +95,10 @@ public abstract class BaseDiagnosticsTest extends JetLiteFixture {
@Override
public TestModule invoke(String name) {
ModuleAndDependencies dependency = modules.get(name);
assert dependency != null : "Dependency not found: " + name + " for module " + moduleAndDependencies.module.getName();
assert dependency != null : "Dependency not found: " +
name +
" for module " +
moduleAndDependencies.module.getName();
return dependency.module;
}
}
@@ -0,0 +1,127 @@
/*
* Copyright 2010-2014 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.checkers;
import com.google.common.io.Files;
import com.intellij.openapi.util.io.FileUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetLiteFixture;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.utils.UtilsPackage;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixture {
protected class ModuleAndDependencies {
final M module;
final List<String> dependencies;
ModuleAndDependencies(M module, List<String> dependencies) {
this.module = module;
this.dependencies = dependencies;
}
}
protected static boolean writeSourceFile(@NotNull String fileName, @NotNull String content, @NotNull File targetDir) {
try {
File sourceFile = new File(targetDir, fileName);
JetTestUtils.mkdirs(sourceFile.getParentFile());
Files.write(content, sourceFile, Charset.forName("utf-8"));
return true;
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
}
}
@Override
protected JetCoreEnvironment createEnvironment() {
File javaFilesDir = createJavaFilesDir();
CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
ConfigurationKind.JDK_AND_ANNOTATIONS,
TestJdkKind.MOCK_JDK,
Arrays.asList(JetTestUtils.getAnnotationsJar()),
Arrays.asList(javaFilesDir)
);
return JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration);
}
protected File createJavaFilesDir() {
File dir = new File(FileUtil.getTempDirectory(), "java-files");
try {
JetTestUtils.mkdirs(dir);
}
catch (IOException e) {
throw UtilsPackage.rethrow(e);
}
return dir;
}
protected void doTest(String filePath) throws Exception {
File file = new File(filePath);
final File javaFilesDir = createJavaFilesDir();
String expectedText = JetTestUtils.doLoadFile(file);
final Map<String, ModuleAndDependencies> modules = new HashMap<String, ModuleAndDependencies>();
List<F> testFiles =
JetTestUtils.createTestFiles(file.getName(), expectedText, new JetTestUtils.TestFileFactory<M, F>() {
@Override
public F createFile(
@Nullable M module,
@NotNull String fileName,
@NotNull String text,
@NotNull Map<String, String> directives
) {
if (fileName.endsWith(".java")) {
writeSourceFile(fileName, text, javaFilesDir);
}
return createTestFile(module, fileName, text, directives);
}
@Override
public M createModule(@NotNull String name, @NotNull List<String> dependencies) {
M module = createTestModule(name);
ModuleAndDependencies oldValue = modules.put(name, new ModuleAndDependencies(module, dependencies));
assert oldValue == null : "Module " + name + " declared more than once";
return module;
}
});
doMultiFileTest(file, modules, testFiles);
}
protected abstract M createTestModule(String name);
protected abstract F createTestFile(M module, String fileName, String text, Map<String, String> directives);
protected abstract void doMultiFileTest(File file, Map<String, ModuleAndDependencies> modules, List<F> files) throws Exception;
}