Make debugger tests work with Idea 14

idea/tests/org/jetbrains/jet/plugin/debugger/AbstractKotlinSteppingTest.kt

@@ -18,21 +18,15 @@ package org.jetbrains.jet.plugin.debugger
 
 import com.intellij.debugger.engine.SuspendContextImpl
 import com.intellij.debugger.engine.MethodFilter
-import com.intellij.debugger.engine.StackFrameContext
 import com.intellij.debugger.engine.DebugProcessImpl
 import org.jetbrains.jet.plugin.debugger.KotlinSmartStepIntoHandler.KotlinMethodSmartStepTarget
 import org.jetbrains.jet.plugin.debugger.KotlinSmartStepIntoHandler.KotlinBasicStepMethodFilter
-import com.intellij.debugger.jdi.StackFrameProxyImpl
-import com.intellij.debugger.SourcePosition
-import com.intellij.psi.PsiElement
 import com.intellij.debugger.DebuggerManagerEx
 import com.intellij.debugger.ui.breakpoints.LineBreakpoint
-import com.intellij.psi.PsiFile
-import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
-import org.jetbrains.jet.lang.resolve.name.FqName
-import java.io.File
 import com.intellij.debugger.actions.MethodSmartStepTarget
 import com.intellij.debugger.engine.BasicStepMethodFilter
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.util.Computable
 
 abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestCase() {
 
@@ -92,19 +86,21 @@ abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestCase() {
 
         val line = (breakpoint as LineBreakpoint).getLineIndex()
 
-        val containingFile = breakpoint.getPsiFile()
+        return ApplicationManager.getApplication()?.runReadAction(Computable {
-        if (containingFile == null) throw AssertionError("Couldn't find file for breakpoint at the line $line")
+            val containingFile = breakpoint.getPsiFile()
+            if (containingFile == null) throw AssertionError("Couldn't find file for breakpoint at the line $line")
 
-        val position = MockSourcePosition(_file = containingFile, _line = line)
+            val position = MockSourcePosition(_file = containingFile, _line = line)
 
-        val stepTargets = KotlinSmartStepIntoHandler().findSmartStepTargets(position)
+            val stepTargets = KotlinSmartStepIntoHandler().findSmartStepTargets(position)
 
-        return stepTargets.filterIsInstance(javaClass<MethodSmartStepTarget>()).map {
+            stepTargets.filterIsInstance(javaClass<MethodSmartStepTarget>()).map {
-            stepTarget ->
+                stepTarget ->
-            when (stepTarget) {
+                when (stepTarget) {
-                is KotlinMethodSmartStepTarget -> KotlinBasicStepMethodFilter(stepTarget as KotlinMethodSmartStepTarget)
+                    is KotlinMethodSmartStepTarget -> KotlinBasicStepMethodFilter(stepTarget as KotlinMethodSmartStepTarget)
-                else -> BasicStepMethodFilter(stepTarget.getMethod(), stepTarget.getCallingExpressionLines())
+                    else -> BasicStepMethodFilter(stepTarget.getMethod(), stepTarget.getCallingExpressionLines())
+                }
             }
-        }
+        })!!
     }
 }

idea/tests/org/jetbrains/jet/plugin/debugger/AbstractSmartStepIntoTest.kt

@@ -25,10 +25,11 @@ import org.jetbrains.jet.InTextDirectivesUtils
 import com.intellij.psi.util.PsiFormatUtil
 import com.intellij.psi.PsiSubstitutor
 import com.intellij.psi.util.PsiFormatUtilBase
+import org.jetbrains.jet.plugin.JetLightCodeInsightFixtureTestCase
 
-abstract class AbstractSmartStepIntoTest : LightCodeInsightFixtureTestCase() {
+abstract class AbstractSmartStepIntoTest : JetLightCodeInsightFixtureTestCase() {
     private val fixture: JavaCodeInsightTestFixture
-        get() = myFixture!!
+        get() = myFixture
 
     protected fun doTest(path: String) {
         fixture.configureByFile(path)

idea/tests/org/jetbrains/jet/plugin/debugger/KotlinDebuggerTestCase.java

@@ -26,12 +26,14 @@ import com.intellij.openapi.roots.OrderRootType;
 import com.intellij.openapi.roots.ui.configuration.libraryEditor.NewLibraryEditor;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.vfs.VfsUtil;
+import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.MockLibraryUtil;
 import org.jetbrains.jet.asJava.KotlinLightClassForPackage;
@@ -66,6 +68,7 @@ public abstract class KotlinDebuggerTestCase extends DebuggerTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
+        VfsRootAccess.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
 
         UsefulTestCase.edt(new Runnable() {
             @Override
@@ -89,6 +92,12 @@ public abstract class KotlinDebuggerTestCase extends DebuggerTestCase {
 
     }
 
+    @Override
+    protected void tearDown() throws Exception {
+        VfsRootAccess.allowRootAccess(JetTestCaseBuilder.getHomeDirectory());
+        super.tearDown();
+    }
+
     @Override
     protected void ensureCompiledAppExists() throws Exception {
         if (!IS_TINY_APP_COMPILED) {

idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractKotlinEvaluateExpressionTest.kt

@@ -40,6 +40,9 @@ import org.apache.log4j.AppenderSkeleton
 import org.apache.log4j.spi.LoggingEvent
 import org.apache.log4j.Level
 import org.apache.log4j.Logger
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.util.Computable
+import com.intellij.psi.PsiDocumentManager
 
 public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestCase() {
     private val logger = Logger.getLogger(javaClass<KotlinEvaluateExpressionCache>())!!
@@ -163,32 +166,37 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestC
     }
 
     private fun SuspendContextImpl.evaluate(text: String, codeFragmentKind: CodeFragmentKind, expectedResult: String) {
-        try {
+        ApplicationManager.getApplication()?.runReadAction {
             val sourcePosition = ContextUtil.getSourcePosition(this)
             val contextElement = ContextUtil.getContextElement(sourcePosition)!!
             Assert.assertTrue("KotlinCodeFragmentFactory should be accepted for context element otherwise default evaluator will be called. ContextElement = ${contextElement.getText()}",
                               KotlinCodeFragmentFactory().isContextAccepted(contextElement))
 
-            val evaluator = DebuggerInvocationUtil.commitAndRunReadAction(getProject()) {
+            try {
-                EvaluatorBuilderImpl.build(TextWithImportsImpl(
-                        codeFragmentKind,
-                        text,
-                        JetCodeFragment.getImportsForElement(contextElement),
-                        JetFileType.INSTANCE),
-                                           contextElement,
-                                           sourcePosition)
-            }
-            if (evaluator == null) throw AssertionError("Cannot create an Evaluator for Evaluate Expression")
 
-            val value = evaluator.evaluate(createEvaluationContext(this))
+                val evaluator =
-            val actualResult = value.asValue().asString()
+                        EvaluatorBuilderImpl.build(TextWithImportsImpl(
-            Assert.assertTrue("Evaluate expression returns wrong result for $text:\nexpected = $expectedResult\nactual   = $actualResult\n", expectedResult == actualResult)
+                                codeFragmentKind,
-        }
+                                text,
-        catch (e: EvaluateException) {
+                                JetCodeFragment.getImportsForElement(contextElement),
-            Assert.assertTrue("Evaluate expression throws wrong exception for $text:\nexpected = $expectedResult\nactual   = ${e.getMessage()}\n", expectedResult == e.getMessage()?.replaceFirst("id=[0-9]*", "id=ID"))
+                                JetFileType.INSTANCE),
-        }
+                                                   contextElement,
-        finally {
+                                                   sourcePosition)
-            resume(this)
+
+
+                if (evaluator == null) throw AssertionError("Cannot create an Evaluator for Evaluate Expression")
+
+                val value = evaluator.evaluate(createEvaluationContext(this))
+                val actualResult = value.asValue().asString()
+
+                Assert.assertTrue("Evaluate expression returns wrong result for $text:\nexpected = $expectedResult\nactual   = $actualResult\n", expectedResult == actualResult)
+            }
+            catch (e: EvaluateException) {
+                Assert.assertTrue("Evaluate expression throws wrong exception for $text:\nexpected = $expectedResult\nactual   = ${e.getMessage()}\n", expectedResult == e.getMessage()?.replaceFirst("id=[0-9]*", "id=ID"))
+            }
+            finally {
+                resume(this)
+            }
         }
     }