From 8d6fd3a18baa8572a4d62406ffc53feb240bac50 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 11 Jul 2012 12:51:58 +0400 Subject: [PATCH] =?UTF-8?q?Base=20classes=20for=20tests=20put=20into=20ord?= =?UTF-8?q?er:=20*=20KotlinTestWithEnvironmentManagement=20=E2=80=94=20met?= =?UTF-8?q?hods=20for=20creating=20envirnoments=20tied=20up=20to=20test=20?= =?UTF-8?q?root=20disposable=20(automatically=20disposed=20on=20teadDown()?= =?UTF-8?q?)=20*=20KotlinTestWithEnvironment=20=E2=80=94=20a=20test=20with?= =?UTF-8?q?=20one=20environment=20(created=20by=20an=20abstract=20method)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Also, utilities for laz yresolve tests moved to LazyResolveTestUtil --- .../jet/KotlinTestWithDefaultEnvironment.java | 40 ------------------- .../KotlinTestWithEnvironmentManagement.java | 40 ++++--------------- ...ractLazyResolveDescriptorRendererTest.java | 10 ++++- .../AbstractLazyResolveDiagnosticsTest.java | 32 +++++++++++++++ ...ractLazyResolveNamespaceComparingTest.java | 13 ++++-- .../lazy/KotlinTestWithEnvironment.java | 36 ++++++++--------- .../lazy/LazyResolveBuiltinClassesTest.java | 9 ++++- .../lazy/LazyResolveStdlibLoadingTest.java | 23 +++++------ ...olveTest.java => LazyResolveTestUtil.java} | 15 +++---- .../org/jetbrains/k2js/test/BasicTest.java | 10 ++++- 10 files changed, 107 insertions(+), 121 deletions(-) delete mode 100644 compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java create mode 100644 compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java rename js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java => compiler/tests/org/jetbrains/jet/lang/resolve/lazy/KotlinTestWithEnvironment.java (57%) rename compiler/tests/org/jetbrains/jet/lang/resolve/lazy/{AbstractLazyResolveTest.java => LazyResolveTestUtil.java} (89%) diff --git a/compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java b/compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java deleted file mode 100644 index 35e74271a9c..00000000000 --- a/compiler/tests/org/jetbrains/jet/KotlinTestWithDefaultEnvironment.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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 index b96ac4e380a..8f0fb0433eb 100644 --- a/compiler/tests/org/jetbrains/jet/KotlinTestWithEnvironmentManagement.java +++ b/compiler/tests/org/jetbrains/jet/KotlinTestWithEnvironmentManagement.java @@ -16,49 +16,25 @@ 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 com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; /** * @author abreslav */ -public abstract class KotlinTestWithEnvironmentManagement extends TestCase { +public abstract class KotlinTestWithEnvironmentManagement extends UsefulTestCase { 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(configurationKind, true); - } - - public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind, boolean mockJdk) { - this.jetCoreEnvironment = new JetCoreEnvironment(rootDisposable, - CompileCompilerDependenciesTest.compilerConfigurationForTests(configurationKind, mockJdk) - ); - this.project = jetCoreEnvironment.getProject(); - } - + protected JetCoreEnvironment createEnvironmentWithMockJdk(@NotNull ConfigurationKind configurationKind) { + return createEnvironmentWithJdk(configurationKind, true); } - @Override - public void tearDown() throws Exception { - Disposer.dispose(rootDisposable); - super.tearDown(); + protected JetCoreEnvironment createEnvironmentWithJdk(@NotNull ConfigurationKind configurationKind, boolean mockJdk) { + return new JetCoreEnvironment(getTestRootDisposable(), + CompileCompilerDependenciesTest.compilerConfigurationForTests(configurationKind, mockJdk) + ); } - } 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 e98dd60d9df..6253bdf48f3 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -22,7 +22,9 @@ import com.intellij.openapi.editor.impl.DocumentImpl; import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiElement; 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.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; @@ -42,12 +44,16 @@ import java.util.List; /** * @author abreslav */ -public abstract class AbstractLazyResolveDescriptorRendererTest extends AbstractLazyResolveTest { +public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTestWithEnvironment { + @Override + protected JetCoreEnvironment createEnvironment() { + return createEnvironmentWithMockJdk(ConfigurationKind.ALL); + } protected void doTest(@NotNull String testFile) throws IOException { - InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment().jetCoreEnvironment); + InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = LazyResolveTestUtil.getEagerInjectorForTopDownAnalyzer(getEnvironment()); JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true)); Collection files = Lists.newArrayList(psiFile); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java new file mode 100644 index 00000000000..d3ce7077cbf --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java @@ -0,0 +1,32 @@ +/* + * 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.lang.resolve.lazy; + +import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; + +/** + * @author abreslav + */ +public class AbstractLazyResolveDiagnosticsTest extends KotlinTestWithEnvironment { + @Override + protected JetCoreEnvironment createEnvironment() { + return createEnvironmentWithMockJdk(ConfigurationKind.ALL); + } + + +} 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 bc399142362..dcb0e1a78be 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java @@ -22,6 +22,7 @@ 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.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.jvm.compiler.NamespaceComparator; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; @@ -39,7 +40,13 @@ import java.util.List; /** * @author abreslav */ -public abstract class AbstractLazyResolveNamespaceComparingTest extends AbstractLazyResolveTest { +public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTestWithEnvironment { + + @Override + protected JetCoreEnvironment createEnvironment() { + return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY); + } + protected void doTest( String testFileName, Function, Pair> transform, @@ -73,8 +80,8 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract Predicate filterJetNamespace, File serializeResultsTo ) { - ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment); - ModuleDescriptor lazyModule = resolveLazily(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment); + ModuleDescriptor module = LazyResolveTestUtil.resolveEagerly(files, getEnvironment()); + ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, getEnvironment()); Pair namespacesToCompare = transform.fun(Pair.create(module, lazyModule)); diff --git a/js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/KotlinTestWithEnvironment.java similarity index 57% rename from js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java rename to compiler/tests/org/jetbrains/jet/lang/resolve/lazy/KotlinTestWithEnvironment.java index 9a00a1942c8..0324e4a7a6f 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/TestWithEnvironment.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/KotlinTestWithEnvironment.java @@ -14,42 +14,40 @@ * limitations under the License. */ -package org.jetbrains.k2js.test; +package org.jetbrains.jet.lang.resolve.lazy; import com.intellij.openapi.project.Project; -import com.intellij.testFramework.UsefulTestCase; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.KotlinTestWithEnvironmentManagement; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.config.CompilerConfiguration; /** - * @author Pavel Talanov + * @author abreslav */ -public abstract class TestWithEnvironment extends UsefulTestCase { - - @Nullable - protected JetCoreEnvironment myEnvironment; - - @NotNull - public Project getProject() { - assert myEnvironment != null : "Environment should be created beforehand."; - return myEnvironment.getProject(); - } +public abstract class KotlinTestWithEnvironment extends KotlinTestWithEnvironmentManagement { + private JetCoreEnvironment environment; @Override protected void setUp() throws Exception { super.setUp(); - createEnvironmentWithMockJdkAndIdeaAnnotations(); + environment = createEnvironment(); } @Override protected void tearDown() throws Exception { - myEnvironment = null; + environment = null; super.tearDown(); } - protected void createEnvironmentWithMockJdkAndIdeaAnnotations() { - myEnvironment = JetCoreEnvironment.createCoreEnvironmentForJVM(getTestRootDisposable(), new CompilerConfiguration()); + protected abstract JetCoreEnvironment createEnvironment(); + + @NotNull + public JetCoreEnvironment getEnvironment() { + return environment; + } + + @NotNull + public Project getProject() { + return getEnvironment().getProject(); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java index 1d366b4c399..a7f4e6cf6ad 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java @@ -23,6 +23,8 @@ import com.google.common.collect.Sets; import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.jvm.compiler.NamespaceComparator; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; @@ -49,7 +51,12 @@ import java.util.Map; /** * @author abreslav */ -public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest { +public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment { + @Override + protected JetCoreEnvironment createEnvironment() { + return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY); + } + @Test public void testJetStandardLibrary() throws Exception { List files = Lists.newArrayList(); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java index c39ec76d834..322a7fc9ffc 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java @@ -24,6 +24,8 @@ import com.intellij.openapi.util.io.FileUtil; import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.KotlinTestWithEnvironmentManagement; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.jvm.compiler.NamespaceComparator; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; @@ -38,15 +40,15 @@ import java.util.regex.Pattern; /** * @author abreslav */ -public class LazyResolveStdlibLoadingTest extends AbstractLazyResolveTest { +public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManagement { private static final File STD_LIB_SRC = new File("libraries/stdlib/src"); - private JetCoreEnvironmentWithDisposable stdlibEnvironment; + private JetCoreEnvironment stdlibEnvironment; @Override protected void setUp() throws Exception { super.setUp(); - stdlibEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_AND_ANNOTATIONS, false); + stdlibEnvironment = createEnvironmentWithJdk(ConfigurationKind.JDK_AND_ANNOTATIONS, false); } protected void doTestForGivenFiles( @@ -55,8 +57,8 @@ public class LazyResolveStdlibLoadingTest extends AbstractLazyResolveTest { List files, Predicate filterJetNamespace ) { - ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_AND_ANNOTATIONS, false).jetCoreEnvironment); - ModuleDescriptor lazyModule = resolveLazily(files, stdlibEnvironment.jetCoreEnvironment); + ModuleDescriptor module = LazyResolveTestUtil.resolveEagerly(files, stdlibEnvironment); + ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment); Pair namespacesToCompare = transform.fun(Pair.create(module, lazyModule)); @@ -76,26 +78,19 @@ public class LazyResolveStdlibLoadingTest extends AbstractLazyResolveTest { //convertToJetFiles(collectKtFiles(new File("compiler/testData/lazyResolve/namespaceComparatorWithJavaMerge"))), convertToJetFiles(collectKtFiles(STD_LIB_SRC)), Predicates.alwaysTrue() - //new Predicate() { - // @Override - // public boolean apply(NamespaceDescriptor descriptor) { - // return Name.identifier("jet").equals(descriptor.getName()); - // } - //}, - //new File("compiler/testData/lazyResolve/namespaceComparatorWithJavaMerge/stdlib-log.txt") ); } private List convertToJetFiles(List files) throws IOException { List jetFiles = Lists.newArrayList(); for (File file : files) { - JetFile jetFile = JetPsiFactory.createFile(getProject(), file.getName(), FileUtil.loadFile(file, true)); + JetFile jetFile = JetPsiFactory.createFile(stdlibEnvironment.getProject(), file.getName(), FileUtil.loadFile(file, true)); jetFiles.add(jetFile); } return jetFiles; } - private List collectKtFiles(@NotNull File root) { + private static List collectKtFiles(@NotNull File root) { List files = Lists.newArrayList(); FileUtil.collectMatchedFiles(root, Pattern.compile(".*?.kt"), files); return files; diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java similarity index 89% rename from compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java rename to compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index fd68d34b641..c10306f3447 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -21,7 +21,6 @@ import com.google.common.base.Predicates; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiFile; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.KotlinTestWithDefaultEnvironment; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; @@ -50,32 +49,31 @@ import java.util.List; /** * @author abreslav */ -public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvironment { - - protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) { +public class LazyResolveTestUtil { + public static InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) { ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("")); 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(getProject(), "")), Collections.emptyList()); + Collections.singletonList(JetPsiFactory.createFile(environment.getProject(), "")), Collections.emptyList()); return tdaInjectorForLazy; } - protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironment environment) { + public static InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironment environment) { TopDownAnalysisParameters params = new TopDownAnalysisParameters( Predicates.alwaysTrue(), false, false, Collections.emptyList()); return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL); } - protected ModuleDescriptor resolveEagerly(List files, JetCoreEnvironment environment) { + public static ModuleDescriptor resolveEagerly(List files, JetCoreEnvironment environment) { ModuleDescriptor module = new ModuleDescriptor(Name.special("")); InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment); injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); return module; } - protected ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { + public static ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment) { ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("")); final Project project = environment.getProject(); @@ -124,5 +122,4 @@ public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvir session = new ResolveSession(project, lazyModule, moduleConfiguration, declarationProviderFactory); return lazyModule; } - } diff --git a/js/js.tests/test/org/jetbrains/k2js/test/BasicTest.java b/js/js.tests/test/org/jetbrains/k2js/test/BasicTest.java index 9bc28c3c075..69125ef0852 100644 --- a/js/js.tests/test/org/jetbrains/k2js/test/BasicTest.java +++ b/js/js.tests/test/org/jetbrains/k2js/test/BasicTest.java @@ -20,6 +20,9 @@ import com.google.common.collect.Lists; import com.intellij.openapi.util.io.FileUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.config.CompilerConfiguration; +import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment; import org.jetbrains.k2js.config.EcmaVersion; import org.jetbrains.k2js.facade.MainCallParameters; import org.jetbrains.k2js.test.config.TestConfig; @@ -38,7 +41,7 @@ import static org.jetbrains.k2js.test.utils.JsTestUtils.convertFileNameToDotJsFi /** * @author Pavel Talanov */ -public abstract class BasicTest extends TestWithEnvironment { +public abstract class BasicTest extends KotlinTestWithEnvironment { private static final boolean DELETE_OUT = false; private static final String TEST_FILES = "js/js.translator/testFiles/"; @@ -56,6 +59,11 @@ public abstract class BasicTest extends TestWithEnvironment { this.mainDirectory = main; } + @Override + protected JetCoreEnvironment createEnvironment() { + return JetCoreEnvironment.createCoreEnvironmentForJVM(getTestRootDisposable(), new CompilerConfiguration()); + } + @NotNull public String getMainDirectory() { return mainDirectory;