Idea 138: workaround enabled "File accessed outside allowed roots"

See IDEA-125568

idea/tests/org/jetbrains/jet/checkers/AbstractJetJsCheckerTest.java

@@ -17,11 +17,11 @@
 package org.jetbrains.jet.checkers;
 
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetStdJSProjectDescriptor;
 
-public abstract class AbstractJetJsCheckerTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractJetJsCheckerTest extends JetLightCodeInsightFixtureTestCase {
     @NotNull
     @Override
     protected LightProjectDescriptor getProjectDescriptor() {

idea/tests/org/jetbrains/jet/checkers/KotlinAndJavaCheckerTest.java

@@ -16,16 +16,17 @@
 
 package org.jetbrains.jet.checkers;
 
-import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase;
 import com.intellij.codeInspection.LocalInspectionTool;
 import com.intellij.codeInspection.nullable.NullableStuffInspection;
 import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
 import com.siyeh.ig.bugs.StaticCallOnSubclassInspection;
 import com.siyeh.ig.bugs.StaticFieldReferenceOnSubclassInspection;
 import org.jetbrains.jet.JetTestCaseBuilder;
+import org.jetbrains.jet.plugin.KotlinDaemonAnalyzerTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
-public class KotlinAndJavaCheckerTest extends DaemonAnalyzerTestCase {
+public class KotlinAndJavaCheckerTest extends KotlinDaemonAnalyzerTestCase {
     @Override
     protected LocalInspectionTool[] configureLocalInspectionTools() {
         return new LocalInspectionTool[] {

idea/tests/org/jetbrains/jet/completion/AbstractKotlinSourceInJavaCompletionTest.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.completion;
 
 import com.intellij.codeInsight.completion.CompletionType;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
@@ -48,6 +49,12 @@ public abstract class AbstractKotlinSourceInJavaCompletionTest extends JetFixtur
         super.doTest(testPath);
     }
 
+    @NotNull
+    @Override
+    protected LightProjectDescriptor getProjectDescriptor() {
+        return JAVA_LATEST;
+    }
+
     @NotNull
     @Override
     protected CompletionType completionType() {

idea/tests/org/jetbrains/jet/completion/AbstractMultiFileJvmBasicCompletionTest.java

@@ -16,19 +16,18 @@
 
 package org.jetbrains.jet.completion;
 
-import com.intellij.codeInsight.completion.CompletionTestCase;
 import com.intellij.codeInsight.lookup.LookupElement;
 import kotlin.Function0;
 import kotlin.Function1;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.completion.util.UtilPackage;
+import org.jetbrains.jet.plugin.KotlinCompletionTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 import org.jetbrains.jet.plugin.project.TargetPlatform;
 import org.jetbrains.jet.plugin.stubs.AstAccessControl;
 
-public abstract class AbstractMultiFileJvmBasicCompletionTest extends CompletionTestCase {
+public abstract class AbstractMultiFileJvmBasicCompletionTest extends KotlinCompletionTestCase {
-
     protected void doTest(@NotNull String testPath) throws Exception {
         configureByFile(getTestName(false) + ".kt", "");
         boolean shouldFail = testPath.contains("NoSpecifiedType");

idea/tests/org/jetbrains/jet/completion/DataFlowValueRenderingTest.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.completion
 
 import org.jetbrains.jet.plugin.PluginTestCaseBase
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.lang.resolve.BindingContext
@@ -27,14 +26,21 @@ import org.jetbrains.jet.plugin.completion.renderDataFlowValue
 import org.jetbrains.jet.JetTestUtils
 import com.intellij.openapi.util.io.FileUtil
 import java.io.File
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase
+import com.intellij.testFramework.LightProjectDescriptor
+import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 
-abstract class AbstractDataFlowValueRenderingTest: LightCodeInsightFixtureTestCase() {
+abstract class AbstractDataFlowValueRenderingTest: JetLightCodeInsightFixtureTestCase() {
     override fun getTestDataPath() : String {
         return PluginTestCaseBase.getTestDataPathBase() + "/dataFlowValueRendering/"
     }
 
+    override fun getProjectDescriptor(): LightProjectDescriptor {
+        return LightCodeInsightFixtureTestCase.JAVA_LATEST
+    }
+
     fun doTest(fileName: String) {
-        val fixture = myFixture!!
+        val fixture = myFixture
         fixture.configureByFile(fileName)
 
         val jetFile = fixture.getFile() as JetFile

idea/tests/org/jetbrains/jet/completion/JetFixtureCompletionBaseTestCase.java

@@ -20,15 +20,15 @@ import com.intellij.codeInsight.CodeInsightSettings;
 import com.intellij.codeInsight.completion.CompletionType;
 import com.intellij.codeInsight.lookup.LookupElement;
 import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.completion.util.UtilPackage;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.project.TargetPlatform;
 
 import java.io.File;
 
-public abstract class JetFixtureCompletionBaseTestCase extends LightCodeInsightFixtureTestCase {
+public abstract class JetFixtureCompletionBaseTestCase extends JetLightCodeInsightFixtureTestCase {
     private boolean autoCompleteSetting;
 
     @Override

idea/tests/org/jetbrains/jet/completion/handlers/CompletionMultifileHandlerTest.java

@@ -16,13 +16,12 @@
 
 package org.jetbrains.jet.completion.handlers;
 
-import com.intellij.codeInsight.completion.CompletionTestCase;
+import org.jetbrains.jet.plugin.KotlinCompletionTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
 import java.io.File;
 
-public class CompletionMultifileHandlerTest extends CompletionTestCase {
+public class CompletionMultifileHandlerTest extends KotlinCompletionTestCase {
-
     public void testExtensionFunctions() throws Exception {
         doTest();
     }

idea/tests/org/jetbrains/jet/completion/handlers/JavaCompletionHandlerTest.java

@@ -16,13 +16,12 @@
 
 package org.jetbrains.jet.completion.handlers;
 
-import com.intellij.codeInsight.completion.CompletionTestCase;
+import org.jetbrains.jet.plugin.KotlinCompletionTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
 import java.io.File;
 
-public class JavaCompletionHandlerTest extends CompletionTestCase {
+public class JavaCompletionHandlerTest extends KotlinCompletionTestCase {
-
     public void testClassAutoImport() {
         doTest();
     }

idea/tests/org/jetbrains/jet/completion/weighers/AbstractCompletionWeigherTest.kt

@@ -20,12 +20,12 @@ import com.intellij.codeInsight.completion.CompletionType
 import org.jetbrains.jet.InTextDirectivesUtils
 import java.io.File
 import org.jetbrains.jet.plugin.PluginTestCaseBase
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.testng.Assert
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.jet.test.util.configureWithExtraFile
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase
 
-public abstract class AbstractCompletionWeigherTest() : LightCodeInsightFixtureTestCase() {
+public abstract class AbstractCompletionWeigherTest() : JetLightCodeInsightFixtureTestCase() {
     fun doTest(path: String) {
         myFixture.configureWithExtraFile(path)
 

idea/tests/org/jetbrains/jet/editor/quickDoc/AbstractJetQuickDocProviderTest.java

@@ -23,9 +23,9 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.rt.execution.junit.FileComparisonFailure;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.InTextDirectivesUtils;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.ProjectDescriptorWithStdlibSources;
 import org.jetbrains.jet.test.util.UtilPackage;
 import org.junit.Assert;
@@ -33,7 +33,7 @@ import org.junit.Assert;
 import java.io.File;
 import java.util.List;
 
-public abstract class AbstractJetQuickDocProviderTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractJetQuickDocProviderTest extends JetLightCodeInsightFixtureTestCase {
     public void doTest(@NotNull String path) throws Exception {
         UtilPackage.configureWithExtraFile(myFixture, path, "_Data");
 

idea/tests/org/jetbrains/jet/findUsages/AbstractJetFindUsagesTest.java

@@ -31,7 +31,6 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import com.intellij.usageView.UsageInfo;
 import com.intellij.usages.UsageGroup;
 import com.intellij.usages.UsageInfo2UsageAdapter;
@@ -48,6 +47,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.InTextDirectivesUtils;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 import org.jetbrains.jet.plugin.findUsages.KotlinClassFindUsagesOptions;
@@ -61,7 +61,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
-public abstract class AbstractJetFindUsagesTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractJetFindUsagesTest extends JetLightCodeInsightFixtureTestCase {
 
     public static final UsageViewPresentation USAGE_VIEW_PRESENTATION = new UsageViewPresentation();
 

idea/tests/org/jetbrains/jet/plugin/JetLightCodeInsightFixtureTestCase.java

@@ -22,6 +22,7 @@ import com.intellij.openapi.actionSystem.ex.ActionManagerEx;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
 import com.intellij.psi.FileViewProvider;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.impl.PsiManagerEx;
@@ -30,6 +31,7 @@ import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.InTextDirectivesUtils;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.references.BuiltInsReferenceResolver;
 import org.jetbrains.jet.utils.UtilsPackage;
@@ -44,13 +46,16 @@ public abstract class JetLightCodeInsightFixtureTestCase extends LightCodeInsigh
     protected void setUp() throws Exception {
         super.setUp();
         ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
     }
 
     @Override
     protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+
         Set<JetFile> builtInsSources = getProject().getComponent(BuiltInsReferenceResolver.class).getBuiltInsSources();
         FileManager fileManager = ((PsiManagerEx) PsiManager.getInstance(getProject())).getFileManager();
-
+        
         super.tearDown();
 
         // Restore mapping between PsiFiles and VirtualFiles dropped in FileManager.cleanupForNextTest(),

idea/tests/org/jetbrains/jet/plugin/KotlinCodeInsightTestCase.java

@@ -0,0 +1,35 @@
+/*
+ * 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.plugin;
+
+import com.intellij.codeInsight.CodeInsightTestCase;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
+import org.jetbrains.jet.JetTestCaseBuilder;
+
+public abstract class KotlinCodeInsightTestCase extends CodeInsightTestCase {
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+        super.tearDown();
+    }
+}

idea/tests/org/jetbrains/jet/plugin/KotlinCompletionTestCase.java

@@ -0,0 +1,35 @@
+/*
+ * 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.plugin;
+
+import com.intellij.codeInsight.completion.CompletionTestCase;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
+import org.jetbrains.jet.JetTestCaseBuilder;
+
+abstract public class KotlinCompletionTestCase extends CompletionTestCase {
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+        super.tearDown();
+    }
+}

idea/tests/org/jetbrains/jet/plugin/KotlinDaemonAnalyzerTestCase.java

@@ -0,0 +1,35 @@
+/*
+ * 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.plugin;
+
+import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
+import org.jetbrains.jet.JetTestCaseBuilder;
+
+abstract public class KotlinDaemonAnalyzerTestCase extends DaemonAnalyzerTestCase {
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+        super.tearDown();
+    }
+}

idea/tests/org/jetbrains/jet/plugin/KotlinHierarchyViewTestBase.java

@@ -0,0 +1,35 @@
+/*
+ * 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.plugin;
+
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
+import com.intellij.testFramework.codeInsight.hierarchy.HierarchyViewTestBase;
+import org.jetbrains.jet.JetTestCaseBuilder;
+
+public abstract class KotlinHierarchyViewTestBase extends HierarchyViewTestBase {
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+        super.tearDown();
+    }
+}

idea/tests/org/jetbrains/jet/plugin/KotlinLightQuickFixTestCase.java

@@ -0,0 +1,35 @@
+/*
+ * 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.plugin;
+
+import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
+import org.jetbrains.jet.JetTestCaseBuilder;
+
+abstract public class KotlinLightQuickFixTestCase extends LightQuickFixTestCase {
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+        super.tearDown();
+    }
+}

idea/tests/org/jetbrains/jet/plugin/WordSelectionTest.java

@@ -16,13 +16,13 @@
 
 package org.jetbrains.jet.plugin;
 
+import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.testFramework.fixtures.CodeInsightTestUtil;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
+import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
 import java.io.File;
 
-public class WordSelectionTest extends LightCodeInsightFixtureTestCase {
+public class WordSelectionTest extends JetLightCodeInsightFixtureTestCase {
     public void testStatements() {
         doTest(11);
     }
@@ -57,6 +57,12 @@ public class WordSelectionTest extends LightCodeInsightFixtureTestCase {
         CodeInsightTestUtil.doWordSelectionTest(myFixture, testName + ".kt", afterFiles);
     }
 
+    @NotNull
+    @Override
+    protected LightProjectDescriptor getProjectDescriptor() {
+        return JAVA_LATEST;
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();

idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOutOfBlockModificationTest.java

@@ -18,16 +18,21 @@ package org.jetbrains.jet.plugin.codeInsight;
 
 import com.intellij.psi.*;
 import com.intellij.psi.impl.JavaCodeBlockModificationListener;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
-public abstract class AbstractOutOfBlockModificationTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractOutOfBlockModificationTest extends JetLightCodeInsightFixtureTestCase {
     @Override
     public void setUp() throws Exception {
         super.setUp();
         myFixture.setTestDataPath(PluginTestCaseBase.getTestDataPathBase() + "/codeInsight/outOfBlock");
     }
 
+    @Override
+    protected String getTestDataPath() {
+        return PluginTestCaseBase.getTestDataPathBase() + "/codeInsight/outOfBlock";
+    }
+
     protected void doTest(String path) {
         myFixture.configureByFile(path);
         String text = myFixture.getDocument(myFixture.getFile()).getText();

idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java

@@ -26,10 +26,9 @@ import com.intellij.psi.impl.source.PostprocessReformattingAspect;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import com.intellij.util.SmartList;
-import kotlin.Function1;
 import junit.framework.Assert;
+import kotlin.Function1;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -40,6 +39,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetLightProjectDescriptor;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
@@ -47,7 +47,7 @@ import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
 import java.util.*;
 
-public abstract class AbstractOverrideImplementTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractOverrideImplementTest extends JetLightCodeInsightFixtureTestCase {
     @NotNull
     @Override
     protected LightProjectDescriptor getProjectDescriptor() {

idea/tests/org/jetbrains/jet/plugin/codeInsight/LiveTemplatesTest.java

@@ -28,11 +28,11 @@ import com.intellij.openapi.command.CommandProcessor;
 import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
 import com.intellij.openapi.editor.actionSystem.EditorActionManager;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
@@ -40,12 +40,11 @@ import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
 
-public class LiveTemplatesTest extends LightCodeInsightFixtureTestCase {
+public class LiveTemplatesTest extends JetLightCodeInsightFixtureTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        myFixture.setTestDataPath(new File(PluginTestCaseBase.getTestDataPathBase(), "/templates").getPath() +
+        myFixture.setTestDataPath(new File(PluginTestCaseBase.getTestDataPathBase(), "/templates").getPath() + File.separator);
-                                  File.separator);
         ((TemplateManagerImpl) TemplateManager.getInstance(getProject())).setTemplateTesting(true);
     }
 

idea/tests/org/jetbrains/jet/plugin/hierarchy/AbstractHierarchyTest.java

@@ -31,10 +31,10 @@ import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.testFramework.MapDataContext;
-import com.intellij.testFramework.codeInsight.hierarchy.HierarchyViewTestBase;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.Processor;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.plugin.KotlinHierarchyViewTestBase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 import org.jetbrains.jet.plugin.hierarchy.calls.KotlinCalleeMethodsTreeStructure;
 import org.jetbrains.jet.plugin.hierarchy.calls.KotlinCallerMethodsTreeStructure;
@@ -50,7 +50,7 @@ Test Hierarchy view
 Format: test build hierarchy for element at caret, file with caret should be the first in the sorted list of files.
 Test accept more than one file, file extension should be .java or .kt
  */
-public abstract class AbstractHierarchyTest extends HierarchyViewTestBase {
+public abstract class AbstractHierarchyTest extends KotlinHierarchyViewTestBase {
 
     private String folderName;
 

idea/tests/org/jetbrains/jet/plugin/highlighter/AbstractHighlightingTest.java

@@ -24,15 +24,15 @@ import com.intellij.lang.annotation.HighlightSeverity;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.rt.execution.junit.FileComparisonFailure;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.InTextDirectivesUtils;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetLightProjectDescriptor;
 
 import java.io.File;
 import java.util.List;
 
-public abstract class AbstractHighlightingTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractHighlightingTest extends JetLightCodeInsightFixtureTestCase {
     @NotNull
     @Override
     protected LightProjectDescriptor getProjectDescriptor() {

idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractQuickFixMultiFileTest.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.plugin.quickfix;
 
-import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase;
 import com.intellij.codeInsight.daemon.impl.HighlightInfo;
 import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
 import com.intellij.codeInsight.intention.IntentionAction;
@@ -30,6 +29,7 @@ import junit.framework.ComparisonFailure;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.DirectiveBasedActionUtils;
+import org.jetbrains.jet.plugin.KotlinDaemonAnalyzerTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
 import java.io.File;
@@ -37,7 +37,7 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
-public abstract class AbstractQuickFixMultiFileTest extends DaemonAnalyzerTestCase {
+public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzerTestCase {
 
     protected static boolean shouldBeAvailableAfterExecution() {
         return false;

idea/tests/org/jetbrains/jet/plugin/quickfix/AbstractQuickFixTest.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.plugin.quickfix;
 
 import com.intellij.codeInsight.daemon.impl.HighlightInfo;
-import com.intellij.codeInsight.daemon.quickFix.LightQuickFixTestCase;
 import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.codeInspection.SuppressIntentionAction;
 import com.intellij.codeInspection.SuppressableProblemGroup;
@@ -28,21 +27,22 @@ import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
-import junit.framework.Assert;
 import org.apache.commons.lang.SystemUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.InTextDirectivesUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.DirectiveBasedActionUtils;
+import org.jetbrains.jet.plugin.KotlinLightQuickFixTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 import org.jetbrains.jet.test.TestMetadata;
 import org.jetbrains.jet.testing.ConfigLibraryUtil;
+import org.junit.Assert;
 
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-public abstract class AbstractQuickFixTest extends LightQuickFixTestCase {
+public abstract class AbstractQuickFixTest extends KotlinLightQuickFixTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();

idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.plugin.refactoring.changeSignature;
 
-import com.intellij.codeInsight.CodeInsightTestCase;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Disposer;
@@ -32,6 +31,7 @@ import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.plugin.KotlinCodeInsightTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.refactoring.JetRefactoringBundle;
@@ -44,7 +44,7 @@ import java.util.List;
 
 import static org.jetbrains.jet.plugin.refactoring.changeSignature.ChangeSignaturePackage.getChangeSignatureDialog;
 
-public class JetChangeSignatureTest extends CodeInsightTestCase {
+public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
     public void testBadSelection() throws Exception {
         configureByFile(getTestName(false) + "Before.kt");
         Editor editor = getEditor();

idea/tests/org/jetbrains/jet/plugin/refactoring/inline/AbstractInlineTest.java

@@ -19,13 +19,12 @@ package org.jetbrains.jet.plugin.refactoring.inline;
 import com.intellij.codeInsight.TargetElementUtilBase;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.InTextDirectivesUtils;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
 
 import java.io.File;
@@ -35,7 +34,7 @@ import java.util.List;
 import static com.intellij.codeInsight.TargetElementUtilBase.ELEMENT_NAME_ACCEPTED;
 import static com.intellij.codeInsight.TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED;
 
-public abstract class AbstractInlineTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractInlineTest extends JetLightCodeInsightFixtureTestCase {
     protected void doTest(@NotNull String path) throws IOException {
         File afterFile = new File(path + ".after");
 

idea/tests/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/AbstractJetExtractionTest.kt

@@ -18,7 +18,6 @@ package org.jetbrains.jet.plugin.refactoring.introduce.introduceVariable
 
 import com.intellij.ide.DataManager
 import com.intellij.psi.PsiElement
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.jetbrains.jet.JetTestCaseBuilder
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.plugin.refactoring.extractFunction.ExtractKotlinFunctionHandler
@@ -32,8 +31,12 @@ import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.psi.PsiWhiteSpace
 import org.jetbrains.jet.lang.psi.JetPackageDirective
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase
+import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
+
+public abstract class AbstractJetExtractionTest() : JetLightCodeInsightFixtureTestCase() {
+    override fun getProjectDescriptor() = LightCodeInsightFixtureTestCase.JAVA_LATEST
 
-public abstract class AbstractJetExtractionTest() : LightCodeInsightFixtureTestCase() {
     val fixture: JavaCodeInsightTestFixture get() = myFixture
 
     protected fun doIntroduceVariableTest(path: String) {

idea/tests/org/jetbrains/jet/plugin/stubs/AbstractLazyResolveByStubTest.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.plugin.stubs;
 
 import com.google.common.base.Predicate;
-import com.intellij.codeInsight.CodeInsightTestCase;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.roots.ContentEntry;
 import com.intellij.openapi.roots.ModifiableRootModel;
@@ -33,6 +32,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
+import org.jetbrains.jet.plugin.KotlinCodeInsightTestCase;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheService;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 import org.jetbrains.jet.test.util.RecursiveDescriptorComparator;
@@ -43,8 +43,7 @@ import java.io.File;
 import static com.intellij.openapi.roots.ModuleRootModificationUtil.updateModel;
 import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.FORBID_ERROR_TYPES;
 
-public abstract class AbstractLazyResolveByStubTest extends CodeInsightTestCase {
+public abstract class AbstractLazyResolveByStubTest extends KotlinCodeInsightTestCase {
-
     protected void doTestCheckingPrimaryConstructorsAndAccessors(String testFileName) throws Exception {
         doTest(testFileName, true, true);
     }

idea/tests/org/jetbrains/jet/plugin/stubs/AbstractMultiFileHighlightingTest.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.plugin.stubs;
 
-import com.intellij.codeInsight.completion.CompletionTestCase;
 import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl;
 import com.intellij.codeInsight.daemon.impl.HighlightInfo;
 import com.intellij.openapi.application.ApplicationManager;
@@ -31,12 +30,13 @@ import com.intellij.testFramework.ExpectedHighlightingData;
 import kotlin.Function0;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.plugin.KotlinCompletionTestCase;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
 import java.io.File;
 import java.util.Collection;
 
-public abstract class AbstractMultiFileHighlightingTest extends CompletionTestCase {
+public abstract class AbstractMultiFileHighlightingTest extends KotlinCompletionTestCase {
 
     public void doTest(@NotNull String filePath) throws Exception {
         configureByFile(new File(filePath).getName(), "");

idea/tests/org/jetbrains/jet/resolve/AbstractReferenceResolveTest.java

@@ -20,21 +20,25 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Ordering;
 import com.intellij.ide.startup.impl.StartupManagerImpl;
 import com.intellij.openapi.startup.StartupManager;
-import com.intellij.psi.PsiElement;
+import com.intellij.openapi.vfs.newvfs.impl.VirtualDirectoryImpl;
-import com.intellij.psi.PsiPolyVariantReference;
+import com.intellij.psi.*;
-import com.intellij.psi.PsiReference;
+import com.intellij.psi.impl.PsiManagerEx;
-import com.intellij.psi.ResolveResult;
+import com.intellij.psi.impl.file.impl.FileManager;
 import com.intellij.testFramework.LightProjectDescriptor;
 import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase;
 import junit.framework.Assert;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.InTextDirectivesUtils;
+import org.jetbrains.jet.JetTestCaseBuilder;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
+import org.jetbrains.jet.plugin.references.BuiltInsReferenceResolver;
 import org.jetbrains.jet.test.util.UtilPackage;
 import org.jetbrains.jet.testing.ReferenceUtils;
 
 import java.io.File;
 import java.util.List;
+import java.util.Set;
 
 public abstract class AbstractReferenceResolveTest extends LightPlatformCodeInsightFixtureTestCase {
     public static class ExpectedResolveData {
@@ -62,6 +66,24 @@ public abstract class AbstractReferenceResolveTest extends LightPlatformCodeInsi
     protected void setUp() throws Exception {
         super.setUp();
         ((StartupManagerImpl) StartupManager.getInstance(getProject())).runPostStartupActivities();
+        VirtualDirectoryImpl.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        VirtualDirectoryImpl.disallowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+
+        Set<JetFile> builtInsSources = getProject().getComponent(BuiltInsReferenceResolver.class).getBuiltInsSources();
+        FileManager fileManager = ((PsiManagerEx) PsiManager.getInstance(getProject())).getFileManager();
+
+        super.tearDown();
+
+        // Restore mapping between PsiFiles and VirtualFiles dropped in FileManager.cleanupForNextTest(),
+        // otherwise built-ins psi elements will become invalid in next test.
+        for (JetFile source : builtInsSources) {
+            FileViewProvider provider = source.getViewProvider();
+            fileManager.setViewProvider(provider.getVirtualFile(), provider);
+        }
     }
 
     protected void doTest(String path) {
@@ -158,6 +180,7 @@ public abstract class AbstractReferenceResolveTest extends LightPlatformCodeInsi
         }
     }
 
+    @NotNull
     @Override
     protected LightProjectDescriptor getProjectDescriptor() {
         return JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE;

idea/tests/org/jetbrains/jet/resolve/AbstractReferenceResolveWithLibTest.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.resolve;
 
 import com.intellij.testFramework.LightProjectDescriptor;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.plugin.JdkAndMockLibraryProjectDescriptor;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 

idea/tests/org/jetbrains/jet/safeDelete/AbstractJetSafeDeleteTest.java

@@ -25,9 +25,9 @@ import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.BaseRefactoringProcessor;
 import com.intellij.refactoring.safeDelete.SafeDeleteHandler;
 import com.intellij.testFramework.LightProjectDescriptor;
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase;
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
@@ -36,7 +36,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-public abstract class AbstractJetSafeDeleteTest extends LightCodeInsightFixtureTestCase {
+public abstract class AbstractJetSafeDeleteTest extends JetLightCodeInsightFixtureTestCase {
     @NotNull
     @Override
     protected LightProjectDescriptor getProjectDescriptor() {

idea/tests/org/jetbrains/jet/shortenRefs/AbstractShortenRefsTest.kt

@@ -16,33 +16,16 @@
 
 package org.jetbrains.jet.shortenRefs
 
-import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.jetbrains.jet.InTextDirectivesUtils
-import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
-import org.jetbrains.jet.lang.psi.JetSimpleNameExpression
-import org.jetbrains.jet.lang.psi.JetExpression
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.psi.JetFile
-import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils
-import org.jetbrains.jet.lang.resolve.name.FqName
-import org.jetbrains.jet.plugin.project.TargetPlatform
 import org.jetbrains.jet.plugin.JetWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.jet.lang.resolve.name.Name
-import com.intellij.util.containers.Predicate
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor
-import com.intellij.openapi.application.Application
 import com.intellij.openapi.application.ApplicationManager
-import org.jetbrains.jet.plugin.PluginTestCaseBase
 import java.io.File
 import com.intellij.openapi.command.CommandProcessor
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.jet.lang.psi.JetReferenceExpression
-import com.intellij.psi.PsiElement
 import org.jetbrains.jet.plugin.codeInsight.ShortenReferences
-import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.JetTestCaseBuilder
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase
 
-abstract class AbstractShortenRefsTest : LightCodeInsightFixtureTestCase() {
+abstract class AbstractShortenRefsTest : JetLightCodeInsightFixtureTestCase() {
     override fun getTestDataPath() = JetTestCaseBuilder.getHomeDirectory()
     override fun getProjectDescriptor() = JetWithJdkAndRuntimeLightProjectDescriptor.INSTANCE