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

Remove dependency to idea.jar in compiler tets to continue running them with JDK 1.6

Browse Source
This commit is contained in:
Nikolay Krasko
2016-03-22 16:48:06 +03:00
parent a642a15947
commit 4f7257ab66
47 changed files with 4016 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.idea/compiler.xml
Generated
-2
View File
@@ -24,7 +24,6 @@
</profile>
</annotationProcessing>
<bytecodeTargetLevel>
<module name="android-idea-plugin" target="1.8" />
<module name="android-studio" target="1.8" />
<module name="bare-plugin" target="1.8" />
<module name="idea" target="1.8" />
@@ -37,7 +36,6 @@
<module name="idea-test-framework" target="1.8" />
<module name="j2k" target="1.8" />
<module name="kannotator-jps-plugin-test" target="1.8" />
<module name="kotlin-android-plugin" target="1.8" />
</bytecodeTargetLevel>
</component>
</project>
.idea/modules.xml
Generated
-1
View File
@@ -66,7 +66,6 @@
<module fileurl="file://$PROJECT_DIR$/compiler/resolution/resolution.iml" filepath="$PROJECT_DIR$/compiler/resolution/resolution.iml" group="compiler" />
<module fileurl="file://$PROJECT_DIR$/core/runtime.jvm/runtime.jvm.iml" filepath="$PROJECT_DIR$/core/runtime.jvm/runtime.jvm.iml" group="core" />
<module fileurl="file://$PROJECT_DIR$/compiler/serialization/serialization.iml" filepath="$PROJECT_DIR$/compiler/serialization/serialization.iml" group="compiler" />
<module fileurl="file://$PROJECT_DIR$/temp-jdk8/temp-jdk8.iml" filepath="$PROJECT_DIR$/temp-jdk8/temp-jdk8.iml" />
<module fileurl="file://$PROJECT_DIR$/compiler/util/util.iml" filepath="$PROJECT_DIR$/compiler/util/util.iml" />
<module fileurl="file://$PROJECT_DIR$/core/util.runtime/util.runtime.iml" filepath="$PROJECT_DIR$/core/util.runtime/util.runtime.iml" group="core" />
</modules>
compiler/tests/com/intellij/testFramework/TestDataFile.java
+29
View File
@@ -0,0 +1,29 @@
/*
* Copyright 2000-2010 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 com.intellij.testFramework;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks the annotated parameter as referencing a file in the testdata directory.
*/
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.PARAMETER})
public @interface TestDataFile {
}
compiler/tests/com/intellij/testFramework/TestDataPath.java
+33
View File
@@ -0,0 +1,33 @@
/*
* Copyright 2010-2016 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 com.intellij.testFramework;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Specifies the path to testdata for the current test case class.
* May use the variable $CONTENT_ROOT to specify the module content root or
* $PROJECT_ROOT to use the project base directory.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface TestDataPath {
String value();
}
compiler/tests/compiler-tests.iml
+38 -2
View File
@@ -13,14 +13,12 @@
<orderEntry type="module" module-name="frontend.java" />
<orderEntry type="module" module-name="cli" />
<orderEntry type="module" module-name="light-classes" />
<orderEntry type="library" name="idea-full" level="project" />
<orderEntry type="library" name="dx-android" level="project" />
<orderEntry type="module" module-name="serialization" />
<orderEntry type="module" module-name="builtins-serializer" />
<orderEntry type="module" module-name="descriptors.runtime" />
<orderEntry type="module" module-name="js.frontend" />
<orderEntry type="module" module-name="js.serializer" />
<orderEntry type="module" module-name="js.tests" />
<orderEntry type="module" module-name="preloader" />
<orderEntry type="module" module-name="android-extensions-compiler" scope="TEST" />
<orderEntry type="module" module-name="js.serializer" />
@@ -29,5 +27,43 @@
<orderEntry type="module" module-name="daemon-client" />
<orderEntry type="module" module-name="daemon-common" />
<orderEntry type="library" scope="TEST" name="kotlin-test" level="project" />
<orderEntry type="library" scope="TEST" name="junit-4.12" level="project" />
<orderEntry type="library" name="intellij-core" level="project" />
<orderEntry type="module-library">
<library>
<CLASSES>
<root url="jar://$MODULE_DIR$/../../ideaSDK/lib/asm4-all.jar!/" />
</CLASSES>
<JAVADOC />
<SOURCES />
</library>
</orderEntry>
<orderEntry type="module-library">
<library>
<CLASSES>
<root url="jar://$MODULE_DIR$/../../ideaSDK/lib/commons-httpclient-3.1-patched.jar!/" />
</CLASSES>
<JAVADOC />
<SOURCES />
</library>
</orderEntry>
<orderEntry type="module-library">
<library>
<CLASSES>
<root url="jar://$MODULE_DIR$/../../dependencies/idea/idea-15-for-tests/lib/idea_rt.jar!/" />
</CLASSES>
<JAVADOC />
<SOURCES />
</library>
</orderEntry>
<orderEntry type="module-library">
<library>
<CLASSES>
<root url="jar://$MODULE_DIR$/../../dependencies/idea/idea-15-for-tests/lib/openapi.jar!/" />
</CLASSES>
<JAVADOC />
<SOURCES />
</library>
</orderEntry>
</component>
</module>
compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt
+2 -2
View File
@@ -17,7 +17,6 @@
package org.jetbrains.kotlin.cli
import com.intellij.ide.highlighter.JavaClassFileType
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.cli.common.ExitCode
import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
@@ -25,10 +24,11 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames
import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import org.jetbrains.org.objectweb.asm.*
import java.io.File
class WrongBytecodeVersionTest : UsefulTestCase() {
class WrongBytecodeVersionTest : KtUsefulTestCase() {
private val incompatibleVersion = JvmBytecodeBinaryVersion(42, 0, 0).toArray()
private fun doTest(relativeDirectory: String) {
compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java
+2 -2
View File
@@ -22,7 +22,6 @@ import com.google.common.collect.Lists;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.testFramework.TestDataFile;
import com.intellij.testFramework.UsefulTestCase;
import kotlin.collections.ArraysKt;
import kotlin.io.FilesKt;
import kotlin.text.Charsets;
@@ -45,6 +44,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.InTextDirectivesUtils;
import org.jetbrains.kotlin.test.KotlinTestUtils;
import org.jetbrains.kotlin.test.TestJdkKind;
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import org.jetbrains.org.objectweb.asm.ClassReader;
import org.jetbrains.org.objectweb.asm.tree.ClassNode;
@@ -75,7 +75,7 @@ import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*;
import static org.jetbrains.kotlin.test.KotlinTestUtils.compilerConfigurationForTests;
import static org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar;
public abstract class CodegenTestCase extends UsefulTestCase {
public abstract class CodegenTestCase extends KtUsefulTestCase {
private static final String DEFAULT_TEST_FILE_NAME = "a_test";
protected KotlinCoreEnvironment myEnvironment;
compiler/tests/org/jetbrains/kotlin/codegen/CustomBytecodeTextTest.kt
+2 -2
View File
@@ -16,8 +16,8 @@
package org.jetbrains.kotlin.codegen
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
class CustomBytecodeTextTest : AbstractBytecodeTextTest() {
fun testEnumMapping() {
@@ -39,7 +39,7 @@ class CustomBytecodeTextTest : AbstractBytecodeTextTest() {
val text = generateToText()
val getstatics = text.lines().filter { it.contains("GETSTATIC MyEnum.") }.map { it.trim() }
UsefulTestCase.assertOrderedEquals("actual bytecode:\n" + text, listOf(
KtUsefulTestCase.assertOrderedEquals("actual bytecode:\n" + text, listOf(
"GETSTATIC MyEnum.${'$'}VALUES : [LMyEnum;",
"GETSTATIC MyEnum.ENTRY4 : LMyEnum;",
"GETSTATIC MyEnum.ENTRY3 : LMyEnum;",
compiler/tests/org/jetbrains/kotlin/codegen/StdlibTest.java
+1 -1
View File
@@ -16,7 +16,6 @@
package org.jetbrains.kotlin.codegen;
import com.intellij.testFramework.TestRunnerUtil;
import junit.framework.*;
import junit.textui.TestRunner;
import org.jetbrains.annotations.NotNull;
@@ -42,6 +41,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.KotlinTestUtils;
import org.jetbrains.kotlin.test.KotlinTestWithEnvironment;
import org.jetbrains.kotlin.test.TestJdkKind;
import org.jetbrains.kotlin.test.testFramework.TestRunnerUtil;
import java.io.File;
import java.lang.reflect.Modifier;
compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
+2 -2
View File
@@ -17,7 +17,6 @@
package org.jetbrains.kotlin.codegen.flags;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.testFramework.UsefulTestCase;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
@@ -26,6 +25,7 @@ import org.jetbrains.kotlin.codegen.GenerationUtils;
import org.jetbrains.kotlin.psi.KtFile;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.KotlinTestUtils;
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
import org.jetbrains.org.objectweb.asm.*;
import java.io.File;
@@ -53,7 +53,7 @@ import static org.jetbrains.kotlin.test.InTextDirectivesUtils.findStringWithPref
* TESTED_OBJECTS: Test, prop$delegate
* FLAGS: ACC_STATIC, ACC_FINAL, ACC_PRIVATE
*/
public abstract class AbstractWriteFlagsTest extends UsefulTestCase {
public abstract class AbstractWriteFlagsTest extends KtUsefulTestCase {
private KotlinCoreEnvironment jetCoreEnvironment;
compiler/tests/org/jetbrains/kotlin/integration/AntTaskJsTest.java
+3 -3
View File
@@ -21,8 +21,8 @@ import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.js.test.rhino.RhinoFunctionResultChecker;
import org.jetbrains.kotlin.js.test.rhino.RhinoUtils;
//import org.jetbrains.kotlin.js.test.rhino.RhinoFunctionResultChecker;
//import org.jetbrains.kotlin.js.test.rhino.RhinoUtils;
import org.jetbrains.kotlin.test.KotlinTestUtils;
import java.io.File;
@@ -61,7 +61,7 @@ public class AntTaskJsTest extends AbstractAntTaskTest {
}
});
RhinoUtils.runRhinoTest(filePaths, new RhinoFunctionResultChecker("out", "foo", "box", "OK"));
//RhinoUtils.runRhinoTest(filePaths, new RhinoFunctionResultChecker("out", "foo", "box", "OK"));
}
private void doJsAntTestForPostfixPrefix(@Nullable String prefix, @Nullable String postfix) throws Exception {
compiler/tests/org/jetbrains/kotlin/integration/KotlinIntegrationTestBase.java
+31 -2
View File
@@ -17,10 +17,13 @@
package org.jetbrains.kotlin.integration;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.OutputListener;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.intellij.execution.process.OSProcessHandler;
import com.intellij.execution.process.ProcessAdapter;
import com.intellij.execution.process.ProcessEvent;
import com.intellij.execution.process.ProcessOutputTypes;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.SystemInfo;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
@@ -141,4 +144,30 @@ public abstract class KotlinIntegrationTestBase extends TestCaseWithTmpdir {
protected static File getKotlinProjectHome() {
return new File(PathManager.getHomePath()).getParentFile();
}
}
private static class OutputListener extends ProcessAdapter {
private final StringBuilder out;
private final StringBuilder err;
public OutputListener(@NotNull StringBuilder out, @NotNull StringBuilder err) {
this.out = out;
this.err = err;
}
@Override
public void onTextAvailable(ProcessEvent event, Key outputType) {
if (outputType == ProcessOutputTypes.STDERR) {
err.append(event.getText());
}
else if (outputType == ProcessOutputTypes.SYSTEM) {
// skip
}
else {
out.append(event.getText());
}
}
@Override
public void processTerminated(ProcessEvent event) {}
}
}
compiler/tests/org/jetbrains/kotlin/jvm/compiler/DeserializedScopeValidationVisitor.kt
+7 -7
View File
@@ -16,16 +16,16 @@
package org.jetbrains.kotlin.jvm.compiler
import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
import org.jetbrains.kotlin.resolve.MemberComparator
import org.jetbrains.kotlin.resolve.scopes.MemberScope
import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberScope
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import org.jetbrains.kotlin.test.util.DescriptorValidator
import org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor
import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.resolve.MemberComparator
class DeserializedScopeValidationVisitor : ValidationVisitor() {
override fun validateScope(scopeOwner: DeclarationDescriptor, scope: MemberScope, collector: DescriptorValidator.DiagnosticCollector) {
@@ -45,7 +45,7 @@ private fun validateDeserializedScope(scopeOwner: DeclarationDescriptor, scope:
}
private fun checkSorted(descriptors: Collection<DeclarationDescriptor>, declaration: DeclarationDescriptor) {
UsefulTestCase.assertOrderedEquals(
KtUsefulTestCase.assertOrderedEquals(
"Members of $declaration should be sorted by serialization.",
descriptors,
descriptors.sortedWith(MemberComparator.INSTANCE)
compiler/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java
+2 -2
View File
@@ -30,8 +30,8 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope;
import java.util.*;
import static com.intellij.testFramework.UsefulTestCase.assertNotNull;
import static com.intellij.testFramework.UsefulTestCase.assertSameElements;
import static org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase.assertNotNull;
import static org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase.assertSameElements;
public class ExpectedLoadErrorsUtil {
public static final String ANNOTATION_CLASS_NAME = "org.jetbrains.kotlin.jvm.compiler.annotation.ExpectLoadError";
compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt
+2 -2
View File
@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.jvm.compiler
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.psi.search.DelegatingGlobalSearchScope
import com.intellij.psi.search.GlobalSearchScope
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.analyzer.ModuleContent
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.analyzer.ResolverForProject
@@ -39,13 +38,14 @@ import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import org.jetbrains.kotlin.test.TestJdkKind
import org.jetbrains.kotlin.types.ErrorUtils
import org.junit.Assert
import java.io.File
import java.util.*
class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
private class TestModule(
val _name: String, val kotlinFiles: List<KtFile>, val javaFilesScope: GlobalSearchScope,
compiler/tests/org/jetbrains/kotlin/parsing/AbstractParsingTest.java
+2 -6
View File
@@ -25,23 +25,19 @@ import com.intellij.psi.PsiErrorElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.testFramework.ParsingTestCase;
import com.intellij.util.PathUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.KtNodeTypes;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.script.KotlinScriptDefinitionProvider;
import org.jetbrains.kotlin.test.KotlinTestUtils;
import org.jetbrains.kotlin.test.testFramework.KtParsingTestCase;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public abstract class AbstractParsingTest extends ParsingTestCase {
static {
System.setProperty("idea.platform.prefix", "Idea");
}
public abstract class AbstractParsingTest extends KtParsingTestCase {
@Override
protected void setUp() throws Exception {
super.setUp();
compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
+2 -2
View File
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.renderer
import com.intellij.openapi.editor.impl.DocumentImpl
import com.intellij.openapi.util.io.FileUtil
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.cli.jvm.config.getModuleName
@@ -39,6 +38,7 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProvid
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import java.io.File
import java.util.*
@@ -147,7 +147,7 @@ abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
val renderedDescriptors = descriptors.map { renderer.render(it) }.joinToString(separator = "\n")
val document = DocumentImpl(psiFile.text)
UsefulTestCase.assertSameLines(KotlinTestUtils.getLastCommentedLines(document), renderedDescriptors.toString())
KtUsefulTestCase.assertSameLines(KotlinTestUtils.getLastCommentedLines(document), renderedDescriptors.toString())
}
override fun createEnvironment(): KotlinCoreEnvironment {
compiler/tests/org/jetbrains/kotlin/renderer/AbstractFunctionDescriptorInExpressionRendererTest.kt
+2 -2
View File
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.renderer
import com.intellij.openapi.editor.impl.DocumentImpl
import com.intellij.openapi.util.io.FileUtil
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor
@@ -31,6 +30,7 @@ import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import org.jetbrains.kotlin.utils.addIfNotNull
import java.io.File
@@ -61,7 +61,7 @@ abstract class AbstractFunctionDescriptorInExpressionRendererTest : KotlinTestWi
val renderedDescriptors = descriptors.map { renderer.render(it) }.joinToString(separator = "\n")
val document = DocumentImpl(file.text)
UsefulTestCase.assertSameLines(KotlinTestUtils.getLastCommentedLines(document), renderedDescriptors.toString())
KtUsefulTestCase.assertSameLines(KotlinTestUtils.getLastCommentedLines(document), renderedDescriptors.toString())
}
override fun createEnvironment(): KotlinCoreEnvironment {
compiler/tests/org/jetbrains/kotlin/repl/AbstractReplInterpreterTest.kt
+2 -2
View File
@@ -17,11 +17,11 @@
package org.jetbrains.kotlin.repl
import com.intellij.openapi.util.text.StringUtil
import com.intellij.testFramework.UsefulTestCase
import org.jetbrains.kotlin.cli.jvm.repl.ReplInterpreter
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.test.TestJdkKind
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import org.junit.Assert
import java.io.File
import java.io.PrintWriter
@@ -37,7 +37,7 @@ private val TRAILING_NEWLINE_REGEX = Regex("\n$")
private val INCOMPLETE_LINE_MESSAGE = "incomplete line"
abstract class AbstractReplInterpreterTest : UsefulTestCase() {
abstract class AbstractReplInterpreterTest : KtUsefulTestCase() {
init {
System.setProperty("java.awt.headless", "true")
}
compiler/tests/org/jetbrains/kotlin/serialization/jvm/BitEncodingTest.java
+2 -2
View File
@@ -16,8 +16,8 @@
package org.jetbrains.kotlin.serialization.jvm;
import com.intellij.testFramework.UsefulTestCase;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
import java.util.Random;
@@ -25,7 +25,7 @@ import static org.jetbrains.kotlin.serialization.jvm.BitEncoding.decodeBytes;
import static org.jetbrains.kotlin.serialization.jvm.BitEncoding.encodeBytes;
import static org.junit.Assert.assertArrayEquals;
public class BitEncodingTest extends UsefulTestCase {
public class BitEncodingTest extends KtUsefulTestCase {
private static final int[] BIG_LENGTHS = new int[]
{1000, 32000, 33000, 65000, 65534, 65535, 65536, 65537, 100000, 131074, 239017, 314159, 1000000};
compiler/tests/org/jetbrains/kotlin/serialization/jvm/JvmNameResolverTest.kt
+3 -6
View File
@@ -16,18 +16,15 @@
package org.jetbrains.kotlin.serialization.jvm
import com.intellij.testFramework.UsefulTestCase
import com.intellij.testFramework.UsefulTestCase.assertEquals
import org.jetbrains.kotlin.load.kotlin.JvmNameResolver
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.StringTableTypes.Record
import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.StringTableTypes.Record.Operation.DESC_TO_CLASS_ID
import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.StringTableTypes.Record.Operation.INTERNAL_TO_CLASS_ID
import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.StringTableTypes.Record.Operation.NONE
import org.jetbrains.kotlin.serialization.jvm.JvmProtoBuf.StringTableTypes.Record.Operation.*
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import java.util.*
class JvmNameResolverTest : UsefulTestCase() {
class JvmNameResolverTest : KtUsefulTestCase() {
private class Context {
val types = JvmProtoBuf.StringTableTypes.newBuilder()
val strings = ArrayList<String>()
compiler/tests/org/jetbrains/kotlin/test/KotlinTestWithEnvironmentManagement.java
+2 -2
View File
@@ -16,12 +16,12 @@
package org.jetbrains.kotlin.test;
import com.intellij.testFramework.UsefulTestCase;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
import org.jetbrains.kotlin.types.DelegatingFlexibleType;
public abstract class KotlinTestWithEnvironmentManagement extends UsefulTestCase {
public abstract class KotlinTestWithEnvironmentManagement extends KtUsefulTestCase {
static {
System.setProperty("java.awt.headless", "true");
DelegatingFlexibleType.RUN_SLOW_ASSERTIONS = true;
compiler/tests/org/jetbrains/kotlin/test/TestCaseWithTmpdir.java
+2 -2
View File
@@ -16,11 +16,11 @@
package org.jetbrains.kotlin.test;
import com.intellij.testFramework.UsefulTestCase;
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase;
import java.io.File;
public abstract class TestCaseWithTmpdir extends UsefulTestCase {
public abstract class TestCaseWithTmpdir extends KtUsefulTestCase {
protected File tmpdir;
@Override
compiler/tests/org/jetbrains/kotlin/test/testFramework/AbstractExceptionCase.java
+35
View File
@@ -0,0 +1,35 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework;
/**
* Base class of block, annotated with exception. Inheritors of this
* class specifies concrete Exception classes
*/
public abstract class AbstractExceptionCase<T extends Throwable> {
public abstract Class<T> getExpectedExceptionClass();
/**
* Suspicious code must be in implementation of this closure
* @throws T
*/
public abstract void tryClosure() throws T;
public String getAssertionErrorMessage() {
return getExpectedExceptionClass().getName() + " must be thrown.";
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/EdtTestUtil.kt
+53
View File
@@ -0,0 +1,53 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework
import com.intellij.util.ThrowableRunnable
import org.jetbrains.annotations.TestOnly
import java.lang.reflect.InvocationTargetException
import javax.swing.SwingUtilities
class EdtTestUtil {
companion object {
@TestOnly @JvmStatic fun runInEdtAndWait(runnable: ThrowableRunnable<Throwable>) {
runInEdtAndWait { runnable.run() }
}
@TestOnly @JvmStatic fun runInEdtAndWait(runnable: Runnable) {
runInEdtAndWait { runnable.run() }
}
}
}
// Test only because in production you must use Application.invokeAndWait(Runnable, ModalityState).
// The problem is - Application logs errors, but not throws. But in tests must be thrown.
// In any case name "runInEdtAndWait" is better than "invokeAndWait".
@TestOnly
fun runInEdtAndWait(runnable: () -> Unit) {
if (SwingUtilities.isEventDispatchThread()) {
runnable()
}
else {
try {
SwingUtilities.invokeAndWait(runnable)
}
catch (e: InvocationTargetException) {
throw e.cause ?: e
}
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/KtParsingTestCase.java
+342
View File
@@ -0,0 +1,342 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework;
import com.intellij.core.CoreASTFactory;
import com.intellij.lang.*;
import com.intellij.lang.impl.PsiBuilderFactoryImpl;
import com.intellij.mock.*;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.EditorFactory;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
import com.intellij.openapi.fileTypes.FileTypeFactory;
import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.options.SchemesManagerFactory;
import com.intellij.openapi.progress.EmptyProgressIndicator;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.progress.impl.CoreProgressManager;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.CharsetToolkit;
import com.intellij.pom.PomModel;
import com.intellij.pom.core.impl.PomModelImpl;
import com.intellij.pom.tree.TreeAspect;
import com.intellij.psi.*;
import com.intellij.psi.impl.DebugUtil;
import com.intellij.psi.impl.PsiCachedValuesFactory;
import com.intellij.psi.impl.PsiFileFactoryImpl;
import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistryImpl;
import com.intellij.psi.impl.source.text.BlockSupportImpl;
import com.intellij.psi.impl.source.text.DiffLog;
import com.intellij.psi.util.CachedValuesManager;
import com.intellij.testFramework.LightVirtualFile;
import com.intellij.util.CachedValuesManagerImpl;
import com.intellij.util.Function;
import com.intellij.util.messages.MessageBus;
import com.intellij.util.messages.MessageBusFactory;
import junit.framework.TestCase;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.test.testFramework.mock.*;
import org.picocontainer.MutablePicoContainer;
import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Set;
@SuppressWarnings("ALL")
public abstract class KtParsingTestCase extends KtPlatformLiteFixture {
public static final Key<Document> HARD_REF_TO_DOCUMENT_KEY = Key.create("HARD_REF_TO_DOCUMENT_KEY");
protected String myFilePrefix;
protected String myFileExt;
protected final String myFullDataPath;
protected PsiFile myFile;
private MockPsiManager myPsiManager;
private PsiFileFactoryImpl myFileFactory;
protected Language myLanguage;
private final ParserDefinition[] myDefinitions;
private final boolean myLowercaseFirstLetter;
protected KtParsingTestCase(@NonNls @NotNull String dataPath, @NotNull String fileExt, @NotNull ParserDefinition... definitions) {
this(dataPath, fileExt, false, definitions);
}
protected KtParsingTestCase(@NonNls @NotNull String dataPath, @NotNull String fileExt, boolean lowercaseFirstLetter, @NotNull ParserDefinition... definitions) {
this.myFilePrefix = "";
this.myDefinitions = definitions;
this.myFullDataPath = this.getTestDataPath() + "/" + dataPath;
this.myFileExt = fileExt;
this.myLowercaseFirstLetter = lowercaseFirstLetter;
}
protected void setUp() throws Exception {
super.setUp();
this.initApplication();
//ComponentAdapter component = getApplication().getPicoContainer().getComponentAdapter(ProgressManager.class.getName());
//if(component == null) {
// getApplication().getPicoContainer().registerComponent(new AbstractComponentAdapter(ProgressManager.class.getName(), Object.class) {
// public Object getComponentInstance(PicoContainer container) throws PicoInitializationException, PicoIntrospectionException {
// return new ProgressManagerImpl();
// }
//
// public void verify(PicoContainer container) throws PicoIntrospectionException {
// }
// });
//}
Extensions.registerAreaClass("IDEA_PROJECT", (String)null);
this.myProject = new MockProjectEx(this.getTestRootDisposable());
this.myPsiManager = new MockPsiManager(this.myProject);
this.myFileFactory = new PsiFileFactoryImpl(this.myPsiManager);
MutablePicoContainer appContainer = getApplication().getPicoContainer();
registerComponentInstance(appContainer, MessageBus.class, MessageBusFactory.newMessageBus(getApplication()));
registerComponentInstance(appContainer, SchemesManagerFactory.class, new MockSchemesManagerFactory());
final MockEditorFactory editorFactory = new MockEditorFactory();
registerComponentInstance(appContainer, EditorFactory.class, editorFactory);
registerComponentInstance(appContainer, FileDocumentManager.class, new MockFileDocumentManagerImpl(new Function<CharSequence, Document>() {
public Document fun(CharSequence charSequence) {
return editorFactory.createDocument(charSequence);
}
}, HARD_REF_TO_DOCUMENT_KEY));
registerComponentInstance(appContainer, PsiDocumentManager.class, new MockPsiDocumentManager());
this.registerApplicationService(PsiBuilderFactory.class, new PsiBuilderFactoryImpl());
this.registerApplicationService(DefaultASTFactory.class, new CoreASTFactory());
this.registerApplicationService(ReferenceProvidersRegistry.class, new ReferenceProvidersRegistryImpl());
registerApplicationService(ProgressManager.class, new CoreProgressManager());
this.myProject.registerService(CachedValuesManager.class, new CachedValuesManagerImpl(this.myProject, new PsiCachedValuesFactory(this.myPsiManager)));
this.myProject.registerService(PsiManager.class, this.myPsiManager);
//this.myProject.registerService(StartupManager.class, new StartupManagerImpl(this.myProject));
this.registerExtensionPoint(FileTypeFactory.FILE_TYPE_FACTORY_EP, FileTypeFactory.class);
ParserDefinition[] pomModel = this.myDefinitions;
int var5 = pomModel.length;
for(int var6 = 0; var6 < var5; ++var6) {
ParserDefinition definition = pomModel[var6];
this.addExplicitExtension(LanguageParserDefinitions.INSTANCE, definition.getFileNodeType().getLanguage(), definition);
}
if(this.myDefinitions.length > 0) {
this.configureFromParserDefinition(this.myDefinitions[0], this.myFileExt);
}
PomModelImpl var8 = new PomModelImpl(this.myProject);
this.myProject.registerService(PomModel.class, var8);
new TreeAspect(var8);
}
public void configureFromParserDefinition(ParserDefinition definition, String extension) {
this.myLanguage = definition.getFileNodeType().getLanguage();
this.myFileExt = extension;
this.addExplicitExtension(LanguageParserDefinitions.INSTANCE, this.myLanguage, definition);
registerComponentInstance(
getApplication().getPicoContainer(), FileTypeManager.class,
new KtMockFileTypeManager(new KtMockLanguageFileType(myLanguage, myFileExt)));
}
protected <T> void addExplicitExtension(final LanguageExtension<T> instance, final Language language, final T object) {
instance.addExplicitExtension(language, object);
Disposer.register(this.myProject, new com.intellij.openapi.Disposable() {
public void dispose() {
instance.removeExplicitExtension(language, object);
}
});
}
protected <T> void registerExtensionPoint(final ExtensionPointName<T> extensionPointName, Class<T> aClass) {
super.registerExtensionPoint(extensionPointName, aClass);
Disposer.register(this.myProject, new com.intellij.openapi.Disposable() {
public void dispose() {
Extensions.getRootArea().unregisterExtensionPoint(extensionPointName.getName());
}
});
}
protected <T> void registerApplicationService(final Class<T> aClass, T object) {
getApplication().registerService(aClass, object);
Disposer.register(this.myProject, new com.intellij.openapi.Disposable() {
public void dispose() {
KtPlatformLiteFixture.getApplication().getPicoContainer().unregisterComponent(aClass.getName());
}
});
}
public MockProjectEx getProject() {
return this.myProject;
}
public MockPsiManager getPsiManager() {
return this.myPsiManager;
}
protected void tearDown() throws Exception {
super.tearDown();
this.myFile = null;
this.myProject = null;
this.myPsiManager = null;
}
protected String getTestDataPath() {
return PathManager.getHomePath();
//return PathManagerEx.getTestDataPath();
}
@NotNull
public final String getTestName() {
return this.getTestName(this.myLowercaseFirstLetter);
}
protected boolean includeRanges() {
return false;
}
protected boolean skipSpaces() {
return false;
}
protected boolean checkAllPsiRoots() {
return true;
}
protected void doTest(boolean checkResult) {
String name = this.getTestName();
try {
String e = this.loadFile(name + "." + this.myFileExt);
this.myFile = this.createPsiFile(name, e);
ensureParsed(this.myFile);
assertEquals("light virtual file text mismatch", e, ((LightVirtualFile)this.myFile.getVirtualFile()).getContent().toString());
assertEquals("virtual file text mismatch", e, LoadTextUtil.loadText(this.myFile.getVirtualFile()));
assertEquals("doc text mismatch", e, this.myFile.getViewProvider().getDocument().getText());
assertEquals("psi text mismatch", e, this.myFile.getText());
ensureCorrectReparse(this.myFile);
if(checkResult) {
this.checkResult(name, this.myFile);
} else {
toParseTreeText(this.myFile, this.skipSpaces(), this.includeRanges());
}
} catch (IOException var4) {
throw new RuntimeException(var4);
}
}
protected void doTest(String suffix) throws IOException {
String name = this.getTestName();
String text = this.loadFile(name + "." + this.myFileExt);
this.myFile = this.createPsiFile(name, text);
ensureParsed(this.myFile);
assertEquals(text, this.myFile.getText());
this.checkResult(name + suffix, this.myFile);
}
protected void doCodeTest(String code) throws IOException {
String name = this.getTestName();
this.myFile = this.createPsiFile("a", code);
ensureParsed(this.myFile);
assertEquals(code, this.myFile.getText());
this.checkResult(this.myFilePrefix + name, this.myFile);
}
protected PsiFile createPsiFile(String name, String text) {
return this.createFile(name + "." + this.myFileExt, text);
}
protected PsiFile createFile(@NonNls String name, String text) {
LightVirtualFile virtualFile = new LightVirtualFile(name, this.myLanguage, text);
virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
return this.createFile(virtualFile);
}
protected PsiFile createFile(LightVirtualFile virtualFile) {
return this.myFileFactory.trySetupPsiForFile(virtualFile, this.myLanguage, true, false);
}
protected void checkResult(@NonNls String targetDataName, PsiFile file) throws IOException {
doCheckResult(this.myFullDataPath, file, this.checkAllPsiRoots(), targetDataName, this.skipSpaces(), this.includeRanges());
}
public static void doCheckResult(String testDataDir, PsiFile file, boolean checkAllPsiRoots, String targetDataName, boolean skipSpaces, boolean printRanges) throws IOException {
FileViewProvider provider = file.getViewProvider();
Set languages = provider.getLanguages();
if(checkAllPsiRoots && languages.size() != 1) {
Iterator var8 = languages.iterator();
while(var8.hasNext()) {
Language language = (Language)var8.next();
PsiFile root = provider.getPsi(language);
String expectedName = targetDataName + "." + language.getID() + ".txt";
doCheckResult(testDataDir, expectedName, toParseTreeText(root, skipSpaces, printRanges).trim());
}
} else {
doCheckResult(testDataDir, targetDataName + ".txt", toParseTreeText(file, skipSpaces, printRanges).trim());
}
}
protected void checkResult(String actual) throws IOException {
String name = this.getTestName();
doCheckResult(this.myFullDataPath, this.myFilePrefix + name + ".txt", actual);
}
protected void checkResult(@NonNls String targetDataName, String actual) throws IOException {
doCheckResult(this.myFullDataPath, targetDataName, actual);
}
public static void doCheckResult(String fullPath, String targetDataName, String actual) throws IOException {
String expectedFileName = fullPath + File.separatorChar + targetDataName;
KtUsefulTestCase.assertSameLinesWithFile(expectedFileName, actual);
}
protected static String toParseTreeText(PsiElement file, boolean skipSpaces, boolean printRanges) {
return DebugUtil.psiToString(file, skipSpaces, printRanges);
}
protected String loadFile(@NonNls String name) throws IOException {
return loadFileDefault(this.myFullDataPath, name);
}
public static String loadFileDefault(String dir, String name) throws IOException {
return FileUtil.loadFile(new File(dir, name), "UTF-8", true).trim();
}
public static void ensureParsed(PsiFile file) {
file.accept(new PsiElementVisitor() {
public void visitElement(PsiElement element) {
element.acceptChildren(this);
}
});
}
public static void ensureCorrectReparse(@NotNull PsiFile file) {
String psiToStringDefault = DebugUtil.psiToString(file, false, false);
String fileText = file.getText();
DiffLog diffLog = (new BlockSupportImpl(file.getProject())).reparseRange(file, TextRange.allOf(fileText), fileText, new EmptyProgressIndicator(), fileText);
diffLog.performActualPsiChange(file);
TestCase.assertEquals(psiToStringDefault, DebugUtil.psiToString(file, false, false));
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/KtPlatformLiteFixture.java
+103
View File
@@ -0,0 +1,103 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework;
import com.intellij.core.CoreEncodingProjectManager;
import com.intellij.mock.MockApplicationEx;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.components.ComponentManager;
import com.intellij.openapi.extensions.ExtensionPoint;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.extensions.ExtensionsArea;
import com.intellij.openapi.fileTypes.FileTypeManager;
import com.intellij.openapi.fileTypes.FileTypeRegistry;
import com.intellij.openapi.util.Getter;
import com.intellij.openapi.vfs.encoding.EncodingManager;
import org.jetbrains.annotations.NotNull;
import org.picocontainer.MutablePicoContainer;
@SuppressWarnings("ALL")
public abstract class KtPlatformLiteFixture extends KtUsefulTestCase {
protected MockProjectEx myProject;
public KtPlatformLiteFixture() {
}
protected void setUp() throws Exception {
super.setUp();
Extensions.cleanRootArea(this.getTestRootDisposable());
}
public static MockApplicationEx getApplication() {
return (MockApplicationEx) ApplicationManager.getApplication();
}
public void initApplication() {
MockApplicationEx instance = new MockApplicationEx(this.getTestRootDisposable());
ApplicationManager.setApplication(instance, new Getter() {
public FileTypeRegistry get() {
return FileTypeManager.getInstance();
}
}, this.getTestRootDisposable());
getApplication().registerService(EncodingManager.class, CoreEncodingProjectManager.class);
}
protected void tearDown() throws Exception {
super.tearDown();
clearFields(this);
this.myProject = null;
}
protected <T> void registerExtension(ExtensionPointName<T> extensionPointName, @NotNull T t) {
this.registerExtension(Extensions.getRootArea(), extensionPointName, t);
}
public <T> void registerExtension(ExtensionsArea area, ExtensionPointName<T> name, T t) {
this.registerExtensionPoint(area, name, (Class<? extends T>) t.getClass());
KtPlatformTestUtil.registerExtension(area, name, t, this.myTestRootDisposable);
}
protected <T> void registerExtensionPoint(ExtensionPointName<T> extensionPointName, Class<T> aClass) {
this.registerExtensionPoint(Extensions.getRootArea(), extensionPointName, aClass);
}
protected <T> void registerExtensionPoint(ExtensionsArea area, ExtensionPointName<T> extensionPointName, Class<? extends T> aClass) {
String name = extensionPointName.getName();
if(!area.hasExtensionPoint(name)) {
ExtensionPoint.Kind kind = !aClass.isInterface() && (aClass.getModifiers() & 1024) == 0 ? ExtensionPoint.Kind.BEAN_CLASS : ExtensionPoint.Kind.INTERFACE;
area.registerExtensionPoint(name, aClass.getName(), kind);
}
}
protected void registerComponentImplementation(MutablePicoContainer container, Class<?> key, Class<?> implementation) {
container.unregisterComponent(key);
container.registerComponentImplementation(key, implementation);
}
public static <T> T registerComponentInstance(MutablePicoContainer container, Class<T> key, T implementation) {
Object old = container.getComponentInstance(key);
container.unregisterComponent(key);
container.registerComponentInstance(key, implementation);
return (T) old;
}
public static <T> T registerComponentInstance(ComponentManager container, Class<T> key, T implementation) {
return registerComponentInstance((MutablePicoContainer)container.getPicoContainer(), key, implementation);
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/KtPlatformTestUtil.java
+905
View File
@@ -0,0 +1,905 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.intellij.execution.process.ProcessOutput;
import com.intellij.execution.util.ExecUtil;
import com.intellij.ide.DataManager;
import com.intellij.ide.util.treeView.AbstractTreeNode;
import com.intellij.ide.util.treeView.AbstractTreeStructure;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.PathManager;
import com.intellij.openapi.extensions.ExtensionPoint;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.extensions.Extensions;
import com.intellij.openapi.extensions.ExtensionsArea;
import com.intellij.openapi.ui.Queryable;
import com.intellij.openapi.util.*;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.VirtualFileFilter;
import com.intellij.util.Alarm;
import com.intellij.util.ArrayUtil;
import com.intellij.util.ReflectionUtil;
import com.intellij.util.ThrowableRunnable;
import com.intellij.util.ui.UIUtil;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jetbrains.annotations.*;
import org.junit.Assert;
import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreePath;
import java.awt.*;
import java.io.*;
import java.nio.charset.Charset;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
@SuppressWarnings("ALL")
public class KtPlatformTestUtil {
public static final boolean COVERAGE_ENABLED_BUILD = "true".equals(System.getProperty("idea.coverage.enabled.build"));
private static final boolean SKIP_HEADLESS = GraphicsEnvironment.isHeadless();
private static final boolean SKIP_SLOW = Boolean.getBoolean("skip.slow.tests.locally");
@NotNull
public static String getTestName(@NotNull String name, boolean lowercaseFirstLetter) {
name = StringUtil.trimStart(name, "test");
return StringUtil.isEmpty(name) ? "" : lowercaseFirstLetter(name, lowercaseFirstLetter);
}
@NotNull
public static String lowercaseFirstLetter(@NotNull String name, boolean lowercaseFirstLetter) {
if (lowercaseFirstLetter && !isAllUppercaseName(name)) {
name = Character.toLowerCase(name.charAt(0)) + name.substring(1);
}
return name;
}
public static boolean isAllUppercaseName(@NotNull String name) {
int uppercaseChars = 0;
for (int i = 0; i < name.length(); i++) {
if (Character.isLowerCase(name.charAt(i))) {
return false;
}
if (Character.isUpperCase(name.charAt(i))) {
uppercaseChars++;
}
}
return uppercaseChars >= 3;
}
public static <T> void registerExtension(@NotNull ExtensionPointName<T> name, @NotNull T t, @NotNull Disposable parentDisposable) {
registerExtension(Extensions.getRootArea(), name, t, parentDisposable);
}
public static <T> void registerExtension(@NotNull ExtensionsArea area, @NotNull ExtensionPointName<T> name, @NotNull final T t, @NotNull Disposable parentDisposable) {
final ExtensionPoint<T> extensionPoint = area.getExtensionPoint(name.getName());
extensionPoint.registerExtension(t);
Disposer.register(parentDisposable, new Disposable() {
@Override
public void dispose() {
extensionPoint.unregisterExtension(t);
}
});
}
@Nullable
protected static String toString(@Nullable Object node, @Nullable Queryable.PrintInfo printInfo) {
if (node instanceof AbstractTreeNode) {
if (printInfo != null) {
return ((AbstractTreeNode)node).toTestString(printInfo);
}
else {
@SuppressWarnings({"deprecation", "UnnecessaryLocalVariable"})
final String presentation = ((AbstractTreeNode)node).getTestPresentation();
return presentation;
}
}
if (node == null) {
return "NULL";
}
return node.toString();
}
public static String print(JTree tree, boolean withSelection) {
return print(tree, tree.getModel().getRoot(), withSelection, null, null);
}
public static String print(JTree tree, Object root, @Nullable Queryable.PrintInfo printInfo, boolean withSelection) {
return print(tree, root, withSelection, printInfo, null);
}
public static String print(JTree tree, boolean withSelection, @Nullable Condition<String> nodePrintCondition) {
return print(tree, tree.getModel().getRoot(), withSelection, null, nodePrintCondition);
}
public static String print(JTree tree, Object root,
boolean withSelection,
@Nullable Queryable.PrintInfo printInfo,
@Nullable Condition<String> nodePrintCondition) {
StringBuilder buffer = new StringBuilder();
final Collection<String> strings = printAsList(tree, root, withSelection, printInfo, nodePrintCondition);
for (String string : strings) {
buffer.append(string).append("\n");
}
return buffer.toString();
}
public static Collection<String> printAsList(JTree tree, boolean withSelection, @Nullable Condition<String> nodePrintCondition) {
return printAsList(tree, tree.getModel().getRoot(), withSelection, null, nodePrintCondition);
}
private static Collection<String> printAsList(JTree tree, Object root,
boolean withSelection,
@Nullable Queryable.PrintInfo printInfo,
Condition<String> nodePrintCondition) {
Collection<String> strings = new ArrayList<String>();
printImpl(tree, root, strings, 0, withSelection, printInfo, nodePrintCondition);
return strings;
}
private static void printImpl(JTree tree,
Object root,
Collection<String> strings,
int level,
boolean withSelection,
@Nullable Queryable.PrintInfo printInfo,
@Nullable Condition<String> nodePrintCondition) {
DefaultMutableTreeNode defaultMutableTreeNode = (DefaultMutableTreeNode)root;
final Object userObject = defaultMutableTreeNode.getUserObject();
String nodeText;
if (userObject != null) {
nodeText = toString(userObject, printInfo);
}
else {
nodeText = "null";
}
if (nodePrintCondition != null && !nodePrintCondition.value(nodeText)) return;
final StringBuilder buff = new StringBuilder();
StringUtil.repeatSymbol(buff, ' ', level);
final boolean expanded = tree.isExpanded(new TreePath(defaultMutableTreeNode.getPath()));
if (!defaultMutableTreeNode.isLeaf()) {
buff.append(expanded ? "-" : "+");
}
final boolean selected = tree.getSelectionModel().isPathSelected(new TreePath(defaultMutableTreeNode.getPath()));
if (withSelection && selected) {
buff.append("[");
}
buff.append(nodeText);
if (withSelection && selected) {
buff.append("]");
}
strings.add(buff.toString());
int childCount = tree.getModel().getChildCount(root);
if (expanded) {
for (int i = 0; i < childCount; i++) {
printImpl(tree, tree.getModel().getChild(root, i), strings, level + 1, withSelection, printInfo, nodePrintCondition);
}
}
}
public static void assertTreeEqual(JTree tree, @NonNls String expected) {
assertTreeEqual(tree, expected, false);
}
public static void assertTreeEqualIgnoringNodesOrder(JTree tree, @NonNls String expected) {
assertTreeEqualIgnoringNodesOrder(tree, expected, false);
}
public static void assertTreeEqual(JTree tree, String expected, boolean checkSelected) {
String treeStringPresentation = print(tree, checkSelected);
Assert.assertEquals(expected, treeStringPresentation);
}
public static void assertTreeEqualIgnoringNodesOrder(JTree tree, String expected, boolean checkSelected) {
final Collection<String> actualNodesPresentation = printAsList(tree, checkSelected, null);
final java.util.List<String> expectedNodes = StringUtil.split(expected, "\n");
KtUsefulTestCase.assertSameElements(actualNodesPresentation, expectedNodes);
}
@TestOnly
public static void waitForAlarm(final int delay) throws InterruptedException {
assert !ApplicationManager.getApplication().isWriteAccessAllowed(): "It's a bad idea to wait for an alarm under the write action. Somebody creates an alarm which requires read action and you are deadlocked.";
assert ApplicationManager.getApplication().isDispatchThread();
final AtomicBoolean invoked = new AtomicBoolean();
final Alarm alarm = new Alarm(Alarm.ThreadToUse.SWING_THREAD);
alarm.addRequest(new Runnable() {
@Override
public void run() {
ApplicationManager.getApplication().invokeLater(new Runnable() {
@Override
public void run() {
alarm.addRequest(new Runnable() {
@Override
public void run() {
invoked.set(true);
}
}, delay);
}
});
}
}, delay);
UIUtil.dispatchAllInvocationEvents();
boolean sleptAlready = false;
while (!invoked.get()) {
UIUtil.dispatchAllInvocationEvents();
//noinspection BusyWait
Thread.sleep(sleptAlready ? 10 : delay);
sleptAlready = true;
}
UIUtil.dispatchAllInvocationEvents();
}
//@TestOnly
//public static void dispatchAllInvocationEventsInIdeEventQueue() throws InterruptedException {
// assert SwingUtilities.isEventDispatchThread() : Thread.currentThread();
// final EventQueue eventQueue = Toolkit.getDefaultToolkit().getSystemEventQueue();
// while (true) {
// AWTEvent event = eventQueue.peekEvent();
// if (event == null) break;
// AWTEvent event1 = eventQueue.getNextEvent();
// if (event1 instanceof InvocationEvent) {
// IdeEventQueue.getInstance().dispatchEvent(event1);
// }
// }
//}
//private static Date raidDate(Bombed bombed) {
// final Calendar instance = Calendar.getInstance();
// instance.set(Calendar.YEAR, bombed.year());
// instance.set(Calendar.MONTH, bombed.month());
// instance.set(Calendar.DAY_OF_MONTH, bombed.day());
// instance.set(Calendar.HOUR_OF_DAY, bombed.time());
// instance.set(Calendar.MINUTE, 0);
//
// return instance.getTime();
//}
//
//public static boolean bombExplodes(Bombed bombedAnnotation) {
// Date now = new Date();
// return now.after(raidDate(bombedAnnotation));
//}
public static StringBuilder print(AbstractTreeStructure structure,
Object node,
int currentLevel,
@Nullable Comparator comparator,
int maxRowCount,
char paddingChar,
@Nullable Queryable.PrintInfo printInfo) {
StringBuilder buffer = new StringBuilder();
doPrint(buffer, currentLevel, node, structure, comparator, maxRowCount, 0, paddingChar, printInfo);
return buffer;
}
private static int doPrint(StringBuilder buffer,
int currentLevel,
Object node,
AbstractTreeStructure structure,
@Nullable Comparator comparator,
int maxRowCount,
int currentLine,
char paddingChar,
@Nullable Queryable.PrintInfo printInfo) {
if (currentLine >= maxRowCount && maxRowCount != -1) return currentLine;
StringUtil.repeatSymbol(buffer, paddingChar, currentLevel);
buffer.append(toString(node, printInfo)).append("\n");
currentLine++;
Object[] children = structure.getChildElements(node);
if (comparator != null) {
ArrayList<?> list = new ArrayList<Object>(Arrays.asList(children));
@SuppressWarnings({"UnnecessaryLocalVariable", "unchecked"}) Comparator<Object> c = comparator;
Collections.sort(list, c);
children = ArrayUtil.toObjectArray(list);
}
for (Object child : children) {
currentLine = doPrint(buffer, currentLevel + 1, child, structure, comparator, maxRowCount, currentLine, paddingChar, printInfo);
}
return currentLine;
}
public static String print(Object[] objects) {
return print(Arrays.asList(objects));
}
public static String print(Collection c) {
StringBuilder result = new StringBuilder();
for (Iterator iterator = c.iterator(); iterator.hasNext();) {
Object each = iterator.next();
result.append(toString(each, null));
if (iterator.hasNext()) {
result.append("\n");
}
}
return result.toString();
}
public static String print(ListModel model) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < model.getSize(); i++) {
result.append(toString(model.getElementAt(i), null));
result.append("\n");
}
return result.toString();
}
public static String print(JTree tree) {
return print(tree, false);
}
public static void assertTreeStructureEquals(final AbstractTreeStructure treeStructure, final String expected) {
Assert.assertEquals(expected, print(treeStructure, treeStructure.getRootElement(), 0, null, -1, ' ', null).toString());
}
public static void invokeNamedAction(final String actionId) {
final AnAction action = ActionManager.getInstance().getAction(actionId);
Assert.assertNotNull(action);
final Presentation presentation = new Presentation();
@SuppressWarnings("deprecation") final DataContext context = DataManager.getInstance().getDataContext();
final AnActionEvent event = AnActionEvent.createFromAnAction(action, null, "", context);
action.update(event);
Assert.assertTrue(presentation.isEnabled());
action.actionPerformed(event);
}
//public static void assertTiming(final String message, final long expectedMs, final long actual) {
// if (COVERAGE_ENABLED_BUILD) return;
//
// final long expectedOnMyMachine = Math.max(1, expectedMs * Timings.MACHINE_TIMING / Timings.ETALON_TIMING);
//
// // Allow 10% more in case of test machine is busy.
// String logMessage = message;
// if (actual > expectedOnMyMachine) {
// int percentage = (int)(100.0 * (actual - expectedOnMyMachine) / expectedOnMyMachine);
// logMessage += ". Operation took " + percentage + "% longer than expected";
// }
// logMessage += ". Expected on my machine: " + expectedOnMyMachine + "." +
// " Actual: " + actual + "." +
// " Expected on Standard machine: " + expectedMs + ";" +
// " Actual on Standard: " + actual * Timings.ETALON_TIMING / Timings.MACHINE_TIMING + ";" +
// " Timings: CPU=" + Timings.CPU_TIMING +
// ", I/O=" + Timings.IO_TIMING + "." +
// " (" + (int)(Timings.MACHINE_TIMING*1.0/Timings.ETALON_TIMING*100) + "% of the Standard)" +
// ".";
// final double acceptableChangeFactor = 1.1;
// if (actual < expectedOnMyMachine) {
// System.out.println(logMessage);
// TeamCityLogger.info(logMessage);
// }
// else if (actual < expectedOnMyMachine * acceptableChangeFactor) {
// TeamCityLogger.warning(logMessage, null);
// }
// else {
// // throw AssertionFailedError to try one more time
// throw new AssertionFailedError(logMessage);
// }
//}
/**
* example usage: startPerformanceTest("calculating pi",100, testRunnable).cpuBound().assertTiming();
*/
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public static TestInfo startPerformanceTest(@NonNls @NotNull String message, int expectedMs, @NotNull ThrowableRunnable test) {
return new TestInfo(test, expectedMs,message);
}
public static boolean canRunTest(@NotNull Class testCaseClass) {
if (!SKIP_SLOW && !SKIP_HEADLESS) {
return true;
}
for (Class<?> clazz = testCaseClass; clazz != null; clazz = clazz.getSuperclass()) {
//if (SKIP_HEADLESS && clazz.getAnnotation(SkipInHeadlessEnvironment.class) != null) {
// System.out.println("Class '" + testCaseClass.getName() + "' is skipped because it requires working UI environment");
// return false;
//}
//if (SKIP_SLOW && clazz.getAnnotation(SkipSlowTestLocally.class) != null) {
// System.out.println("Class '" + testCaseClass.getName() + "' is skipped because it is dog slow");
// return false;
//}
}
return true;
}
public static void assertPathsEqual(@Nullable String expected, @Nullable String actual) {
if (expected != null) expected = FileUtil.toSystemIndependentName(expected);
if (actual != null) actual = FileUtil.toSystemIndependentName(actual);
Assert.assertEquals(expected, actual);
}
@NotNull
public static String getRtJarPath() {
String home = System.getProperty("java.home");
return SystemInfo.isAppleJvm ? FileUtil.toCanonicalPath(home + "/../Classes/classes.jar") : home + "/lib/rt.jar";
}
//public static void saveProject(Project project) {
// ApplicationEx application = ApplicationManagerEx.getApplicationEx();
// boolean oldValue = application.isDoNotSave();
// try {
// application.doNotSave(false);
// project.save();
// }
// finally {
// application.doNotSave(oldValue);
// }
//}
public static class TestInfo {
private final ThrowableRunnable test; // runnable to measure
private final int expectedMs; // millis the test is expected to run
private ThrowableRunnable setup; // to run before each test
private boolean usesAllCPUCores; // true if the test runs faster on multi-core
private int attempts = 4; // number of retries if performance failed
private final String message; // to print on fail
private boolean adjustForIO = true; // true if test uses IO, timings need to be re-calibrated according to this agent disk performance
private boolean adjustForCPU = true; // true if test uses CPU, timings need to be re-calibrated according to this agent CPU speed
private boolean useLegacyScaling;
private TestInfo(@NotNull ThrowableRunnable test, int expectedMs, String message) {
this.test = test;
this.expectedMs = expectedMs;
assert expectedMs > 0 : "Expected must be > 0. Was: "+ expectedMs;
this.message = message;
}
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public TestInfo setup(@NotNull ThrowableRunnable setup) { assert this.setup==null; this.setup = setup; return this; }
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public TestInfo usesAllCPUCores() { assert adjustForCPU : "This test configured to be io-bound, it cannot use all cores"; usesAllCPUCores = true; return this; }
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public TestInfo cpuBound() { adjustForIO = false; adjustForCPU = true; return this; }
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public TestInfo ioBound() { adjustForIO = true; adjustForCPU = false; return this; }
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public TestInfo attempts(int attempts) { this.attempts = attempts; return this; }
/**
* @deprecated Enables procedure for nonlinear scaling of results between different machines. This was historically enabled, but doesn't
* seem to be meaningful, and is known to make results worse in some cases. Consider migration off this setting, recalibrating
* expected execution time accordingly.
*/
@Contract(pure = true) // to warn about not calling .assertTiming() in the end
public TestInfo useLegacyScaling() { useLegacyScaling = true; return this; }
//public void assertTiming() {
// assert expectedMs != 0 : "Must call .expect() before run test";
// if (COVERAGE_ENABLED_BUILD) return;
// Timings.getStatistics(); // warm-up, measure
//
// while (true) {
// attempts--;
// long start;
// try {
// if (setup != null) setup.run();
// start = System.currentTimeMillis();
// test.run();
// }
// catch (Throwable throwable) {
// throw new RuntimeException(throwable);
// }
// long finish = System.currentTimeMillis();
// long duration = finish - start;
//
// int expectedOnMyMachine = expectedMs;
// if (adjustForCPU) {
// expectedOnMyMachine = adjust(expectedOnMyMachine, Timings.CPU_TIMING, Timings.ETALON_CPU_TIMING, useLegacyScaling);
//
// expectedOnMyMachine = usesAllCPUCores ? expectedOnMyMachine * 8 / JobSchedulerImpl.CORES_COUNT : expectedOnMyMachine;
// }
// if (adjustForIO) {
// expectedOnMyMachine = adjust(expectedOnMyMachine, Timings.IO_TIMING, Timings.ETALON_IO_TIMING, useLegacyScaling);
// }
//
// // Allow 10% more in case of test machine is busy.
// String logMessage = message;
// if (duration > expectedOnMyMachine) {
// int percentage = (int)(100.0 * (duration - expectedOnMyMachine) / expectedOnMyMachine);
// logMessage += ": " + percentage + "% longer";
// }
// logMessage +=
// ". Expected: " + formatTime(expectedOnMyMachine) + ". Actual: " + formatTime(duration) + "." + Timings.getStatistics();
// final double acceptableChangeFactor = 1.1;
// if (duration < expectedOnMyMachine) {
// int percentage = (int)(100.0 * (expectedOnMyMachine - duration) / expectedOnMyMachine);
// logMessage = percentage + "% faster. " + logMessage;
//
// TeamCityLogger.info(logMessage);
// System.out.println("SUCCESS: " + logMessage);
// }
// else if (duration < expectedOnMyMachine * acceptableChangeFactor) {
// TeamCityLogger.warning(logMessage, null);
// System.out.println("WARNING: " + logMessage);
// }
// else {
// // try one more time
// if (attempts == 0) {
// //try {
// // Object result = Class.forName("com.intellij.util.ProfilingUtil").getMethod("captureCPUSnapshot").invoke(null);
// // System.err.println("CPU snapshot captured in '"+result+"'");
// //}
// //catch (Exception e) {
// //}
//
// throw new AssertionFailedError(logMessage);
// }
// System.gc();
// System.gc();
// System.gc();
// String s = "Another epic fail (remaining attempts: " + attempts + "): " + logMessage;
// TeamCityLogger.warning(s, null);
// System.err.println(s);
// //if (attempts == 1) {
// // try {
// // Class.forName("com.intellij.util.ProfilingUtil").getMethod("startCPUProfiling").invoke(null);
// // }
// // catch (Exception e) {
// // }
// //}
// continue;
// }
// break;
// }
//}
private static String formatTime(long millis) {
String hint = "";
DecimalFormat format = new DecimalFormat("#.0", DecimalFormatSymbols.getInstance(Locale.US));
if (millis >= 60 * 1000) hint = format.format(millis / 60 / 1000.f) + "m";
if (millis >= 1000) hint += (hint.isEmpty() ? "" : " ") + format.format(millis / 1000.f) + "s";
String result = millis + "ms";
if (!hint.isEmpty()) {
result = result + " (" + hint + ")";
}
return result;
}
private static int adjust(int expectedOnMyMachine, long thisTiming, long etalonTiming, boolean useLegacyScaling) {
if (useLegacyScaling) {
double speed = 1.0 * thisTiming / etalonTiming;
double delta = speed < 1
? 0.9 + Math.pow(speed - 0.7, 2)
: 0.45 + Math.pow(speed - 0.25, 2);
expectedOnMyMachine *= delta;
return expectedOnMyMachine;
}
else {
return (int)(expectedOnMyMachine * thisTiming / etalonTiming);
}
}
}
//public static void assertTiming(String message, long expected, @NotNull Runnable actionToMeasure) {
// assertTiming(message, expected, 4, actionToMeasure);
//}
public static long measure(@NotNull Runnable actionToMeasure) {
long start = System.currentTimeMillis();
actionToMeasure.run();
long finish = System.currentTimeMillis();
return finish - start;
}
//public static void assertTiming(String message, long expected, int attempts, @NotNull Runnable actionToMeasure) {
// while (true) {
// attempts--;
// long duration = measure(actionToMeasure);
// try {
// assertTiming(message, expected, duration);
// break;
// }
// catch (AssertionFailedError e) {
// if (attempts == 0) throw e;
// System.gc();
// System.gc();
// System.gc();
// String s = "Another epic fail (remaining attempts: " + attempts + "): " + e.getMessage();
// TeamCityLogger.warning(s, null);
// System.err.println(s);
// }
// }
//}
private static com.intellij.util.containers.HashMap<String, VirtualFile> buildNameToFileMap(VirtualFile[] files, @Nullable VirtualFileFilter filter) {
com.intellij.util.containers.HashMap<String, VirtualFile> map = new com.intellij.util.containers.HashMap<String, VirtualFile>();
for (VirtualFile file : files) {
if (filter != null && !filter.accept(file)) continue;
map.put(file.getName(), file);
}
return map;
}
//public static void assertDirectoriesEqual(VirtualFile dirAfter, VirtualFile dirBefore) throws IOException {
// assertDirectoriesEqual(dirAfter, dirBefore, null);
//}
//@SuppressWarnings("UnsafeVfsRecursion")
//public static void assertDirectoriesEqual(VirtualFile dirAfter, VirtualFile dirBefore, @Nullable VirtualFileFilter fileFilter) throws IOException {
// FileDocumentManager.getInstance().saveAllDocuments();
//
// VirtualFile[] childrenAfter = dirAfter.getChildren();
//
// if (dirAfter.isInLocalFileSystem() && dirAfter.getFileSystem() != TempFileSystem.getInstance()) {
// File[] ioAfter = new File(dirAfter.getPath()).listFiles();
// shallowCompare(childrenAfter, ioAfter);
// }
//
// VirtualFile[] childrenBefore = dirBefore.getChildren();
// if (dirBefore.isInLocalFileSystem() && dirBefore.getFileSystem() != TempFileSystem.getInstance()) {
// File[] ioBefore = new File(dirBefore.getPath()).listFiles();
// shallowCompare(childrenBefore, ioBefore);
// }
//
// com.intellij.util.containers.HashMap<String, VirtualFile> mapAfter = buildNameToFileMap(childrenAfter, fileFilter);
// com.intellij.util.containers.HashMap<String, VirtualFile> mapBefore = buildNameToFileMap(childrenBefore, fileFilter);
//
// Set<String> keySetAfter = mapAfter.keySet();
// Set<String> keySetBefore = mapBefore.keySet();
// Assert.assertEquals(dirAfter.getPath(), keySetAfter, keySetBefore);
//
// for (String name : keySetAfter) {
// VirtualFile fileAfter = mapAfter.get(name);
// VirtualFile fileBefore = mapBefore.get(name);
// if (fileAfter.isDirectory()) {
// assertDirectoriesEqual(fileAfter, fileBefore, fileFilter);
// }
// else {
// assertFilesEqual(fileAfter, fileBefore);
// }
// }
//}
private static void shallowCompare(VirtualFile[] vfs, @Nullable File[] io) {
java.util.List<String> vfsPaths = new ArrayList<String>();
for (VirtualFile file : vfs) {
vfsPaths.add(file.getPath());
}
java.util.List<String> ioPaths = new ArrayList<String>();
if (io != null) {
for (File file : io) {
ioPaths.add(file.getPath().replace(File.separatorChar, '/'));
}
}
Assert.assertEquals(sortAndJoin(vfsPaths), sortAndJoin(ioPaths));
}
private static String sortAndJoin(java.util.List<String> strings) {
Collections.sort(strings);
StringBuilder buf = new StringBuilder();
for (String string : strings) {
buf.append(string);
buf.append('\n');
}
return buf.toString();
}
//public static void assertFilesEqual(VirtualFile fileAfter, VirtualFile fileBefore) throws IOException {
// try {
// assertJarFilesEqual(VfsUtilCore.virtualToIoFile(fileAfter), VfsUtilCore.virtualToIoFile(fileBefore));
// }
// catch (IOException e) {
// FileDocumentManager manager = FileDocumentManager.getInstance();
//
// Document docBefore = manager.getDocument(fileBefore);
// boolean canLoadBeforeText = !fileBefore.getFileType().isBinary() || fileBefore.getFileType() == FileTypes.UNKNOWN;
// String textB = docBefore != null
// ? docBefore.getText()
// : !canLoadBeforeText
// ? null
// : LoadTextUtil.getTextByBinaryPresentation(fileBefore.contentsToByteArray(false), fileBefore).toString();
//
// Document docAfter = manager.getDocument(fileAfter);
// boolean canLoadAfterText = !fileBefore.getFileType().isBinary() || fileBefore.getFileType() == FileTypes.UNKNOWN;
// String textA = docAfter != null
// ? docAfter.getText()
// : !canLoadAfterText
// ? null
// : LoadTextUtil.getTextByBinaryPresentation(fileAfter.contentsToByteArray(false), fileAfter).toString();
//
// if (textA != null && textB != null) {
// Assert.assertEquals(fileAfter.getPath(), textA, textB);
// }
// else {
// Assert.assertArrayEquals(fileAfter.getPath(), fileAfter.contentsToByteArray(), fileBefore.contentsToByteArray());
// }
// }
//}
//public static void assertJarFilesEqual(File file1, File file2) throws IOException {
// final File tempDirectory1;
// final File tempDirectory2;
//
// final JarFile jarFile1 = new JarFile(file1);
// try {
// final JarFile jarFile2 = new JarFile(file2);
// try {
// tempDirectory1 = PlatformTestCase.createTempDir("tmp1");
// tempDirectory2 = PlatformTestCase.createTempDir("tmp2");
// ZipUtil.extract(jarFile1, tempDirectory1, null);
// ZipUtil.extract(jarFile2, tempDirectory2, null);
// }
// finally {
// jarFile2.close();
// }
// }
// finally {
// jarFile1.close();
// }
//
// final VirtualFile dirAfter = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory1);
// Assert.assertNotNull(tempDirectory1.toString(), dirAfter);
// final VirtualFile dirBefore = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory2);
// Assert.assertNotNull(tempDirectory2.toString(), dirBefore);
// ApplicationManager.getApplication().runWriteAction(new Runnable() {
// @Override
// public void run() {
// dirAfter.refresh(false, true);
// dirBefore.refresh(false, true);
// }
// });
// assertDirectoriesEqual(dirAfter, dirBefore);
//}
public static void assertElementsEqual(final Element expected, final Element actual) throws IOException {
if (!JDOMUtil.areElementsEqual(expected, actual)) {
Assert.assertEquals(printElement(expected), printElement(actual));
}
}
public static void assertElementEquals(final String expected, final Element actual) {
try {
assertElementsEqual(JDOMUtil.loadDocument(expected).getRootElement(), actual);
}
catch (IOException e) {
throw new AssertionError(e);
}
catch (JDOMException e) {
throw new AssertionError(e);
}
}
public static String printElement(final Element element) throws IOException {
final StringWriter writer = new StringWriter();
JDOMUtil.writeElement(element, writer, "\n");
return writer.getBuffer().toString();
}
public static String getCommunityPath() {
final String homePath = PathManager.getHomePath();
if (new File(homePath, "community/.idea").isDirectory()) {
return homePath + File.separatorChar + "community";
}
return homePath;
}
public static String getPlatformTestDataPath() {
return getCommunityPath().replace(File.separatorChar, '/') + "/platform/platform-tests/testData/";
}
public static Comparator<AbstractTreeNode> createComparator(final Queryable.PrintInfo printInfo) {
return new Comparator<AbstractTreeNode>() {
@Override
public int compare(final AbstractTreeNode o1, final AbstractTreeNode o2) {
String displayText1 = o1.toTestString(printInfo);
String displayText2 = o2.toTestString(printInfo);
return Comparing.compare(displayText1, displayText2);
}
};
}
@NotNull
public static <T> T notNull(@Nullable T t) {
Assert.assertNotNull(t);
return t;
}
@NotNull
public static String loadFileText(@NotNull String fileName) throws IOException {
return StringUtil.convertLineSeparators(FileUtil.loadFile(new File(fileName)));
}
//public static void tryGcSoftlyReachableObjects() {
// GCUtil.tryGcSoftlyReachableObjects();
//}
public static void withEncoding(@NotNull String encoding, @NotNull final Runnable r) {
withEncoding(encoding, new ThrowableRunnable() {
@Override
public void run() throws Throwable {
r.run();
}
});
}
public static void withEncoding(@NotNull String encoding, @NotNull ThrowableRunnable r) {
Charset oldCharset = Charset.defaultCharset();
try {
try {
patchSystemFileEncoding(encoding);
r.run();
}
finally {
patchSystemFileEncoding(oldCharset.name());
}
}
catch (Throwable t) {
throw new RuntimeException(t);
}
}
private static void patchSystemFileEncoding(String encoding) {
ReflectionUtil.resetField(Charset.class, Charset.class, "defaultCharset");
System.setProperty("file.encoding", encoding);
}
public static void withStdErrSuppressed(@NotNull Runnable r) {
PrintStream std = System.err;
System.setErr(new PrintStream(NULL));
try {
r.run();
}
finally {
System.setErr(std);
}
}
@SuppressWarnings("IOResourceOpenedButNotSafelyClosed")
private static final OutputStream NULL = new OutputStream() {
@Override
public void write(int b) throws IOException { }
};
public static void assertSuccessful(@NotNull GeneralCommandLine command) {
try {
ProcessOutput output = ExecUtil.execAndGetOutput(command.withRedirectErrorStream(true));
Assert.assertEquals(output.getStdout(), 0, output.getExitCode());
}
catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/KtUsefulTestCase.java
+1113
View File
File diff suppressed because it is too large Load Diff
compiler/tests/org/jetbrains/kotlin/test/testFramework/MockProjects.kt
+45
View File
@@ -0,0 +1,45 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework
import com.intellij.mock.MockProject
import com.intellij.openapi.Disposable
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.project.Project
import com.intellij.util.messages.Topic
interface ProjectEx : Project {
interface ProjectSaved {
fun saved(project: Project)
companion object {
val TOPIC = Topic.create("SaveProjectTopic", ProjectSaved::class.java, Topic.BroadcastDirection.NONE)
}
}
fun init()
fun setProjectName(name: String)
}
class MockProjectEx(parentDisposable: Disposable) : MockProject(if (ApplicationManager.getApplication() != null) ApplicationManager.getApplication().picoContainer else null, parentDisposable), ProjectEx {
override fun setProjectName(name: String) {
}
override fun init() {
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/TestRunnerUtil.java
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework;
import org.jetbrains.annotations.TestOnly;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class TestRunnerUtil {
private TestRunnerUtil() {
}
@TestOnly
public static boolean isJUnit4TestClass(final Class aClass) {
final int modifiers = aClass.getModifiers();
if ((modifiers & Modifier.ABSTRACT) != 0) return false;
if ((modifiers & Modifier.PUBLIC) == 0) return false;
if (aClass.getAnnotation(RunWith.class) != null) return true;
for (Method method : aClass.getMethods()) {
if (method.getAnnotation(Test.class) != null) return true;
}
return false;
}
//public static void replaceIdeEventQueueSafely() {
// if (Toolkit.getDefaultToolkit().getSystemEventQueue() instanceof IdeEventQueue) {
// return;
// }
// if (SwingUtilities.isEventDispatchThread()) {
// throw new RuntimeException("must not call under EDT");
// }
// AWTAutoShutdown.getInstance().notifyThreadBusy(Thread.currentThread());
// UIUtil.pump();
// // in JDK 1.6 java.awt.EventQueue.push() causes slow painful death of current EDT
// // so we have to wait through its agony to termination
// try {
// SwingUtilities.invokeAndWait(new Runnable() {
// @Override
// public void run() {
// IdeEventQueue.getInstance();
// }
// });
// SwingUtilities.invokeAndWait(EmptyRunnable.getInstance());
// SwingUtilities.invokeAndWait(EmptyRunnable.getInstance());
// }
// catch (Exception e) {
// throw new RuntimeException(e);
// }
//}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/VfsTestUtil.java
+151
View File
@@ -0,0 +1,151 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework;
import com.intellij.openapi.application.AccessToken;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.WriteAction;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.SystemInfo;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VfsUtil;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.PathUtil;
import com.intellij.util.text.StringTokenizer;
import org.jetbrains.annotations.NotNull;
import org.junit.Assert;
import java.io.File;
import java.io.IOException;
public class VfsTestUtil {
public static final Key<String> TEST_DATA_FILE_PATH = Key.create("TEST_DATA_FILE_PATH");
private VfsTestUtil() {
}
public static VirtualFile createFile(final VirtualFile root, final String relativePath) {
return createFile(root, relativePath, "");
}
public static VirtualFile createFile(final VirtualFile root, final String relativePath, final String text) {
return createFileOrDir(root, relativePath, text, false);
}
public static VirtualFile createDir(final VirtualFile root, final String relativePath) {
return createFileOrDir(root, relativePath, "", true);
}
private static VirtualFile createFileOrDir(final VirtualFile root,
final String relativePath,
final String text,
final boolean dir) {
try {
AccessToken token = WriteAction.start();
try {
VirtualFile parent = root;
Assert.assertNotNull(parent);
StringTokenizer parents = new StringTokenizer(PathUtil.getParentPath(relativePath), "/");
while (parents.hasMoreTokens()) {
final String name = parents.nextToken();
VirtualFile child = parent.findChild(name);
if (child == null || !child.isValid()) {
child = parent.createChildDirectory(VfsTestUtil.class, name);
}
parent = child;
}
VirtualFile file;
parent.getChildren();//need this to ensure that fileCreated event is fired
if (dir) {
file = parent.createChildDirectory(VfsTestUtil.class, PathUtil.getFileName(relativePath));
}
else {
file = parent.findFileByRelativePath(relativePath);
if (file == null) {
file = parent.createChildData(VfsTestUtil.class, PathUtil.getFileName(relativePath));
}
VfsUtil.saveText(file, text);
}
return file;
}
finally {
token.finish();
}
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void deleteFile(@NotNull VirtualFile file) {
UtilKt.deleteFile(file);
}
public static void clearContent(@NotNull final VirtualFile file) {
ApplicationManager.getApplication().runWriteAction(new Runnable() {
@Override
public void run() {
try {
VfsUtil.saveText(file, "");
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
});
}
@SuppressWarnings("UnusedDeclaration")
public static void overwriteTestData(String filePath, String actual) {
try {
FileUtil.writeToFile(new File(filePath), actual);
}
catch (IOException e) {
throw new AssertionError(e);
}
}
@NotNull
public static VirtualFile findFileByCaseSensitivePath(@NotNull String absolutePath) {
String vfsPath = FileUtil.toSystemIndependentName(absolutePath);
VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(vfsPath);
Assert.assertNotNull("file " + absolutePath + " not found", vFile);
String realVfsPath = vFile.getPath();
if (!SystemInfo.isFileSystemCaseSensitive && !vfsPath.equals(realVfsPath) &&
vfsPath.equalsIgnoreCase(realVfsPath)) {
Assert.fail("Please correct case-sensitivity of path to prevent test failure on case-sensitive file systems:\n" +
" path " + vfsPath + "\n" +
"real path " + realVfsPath);
}
return vFile;
}
public static void assertFilePathEndsWithCaseSensitivePath(@NotNull VirtualFile file, @NotNull String suffixPath) {
String vfsSuffixPath = FileUtil.toSystemIndependentName(suffixPath);
String vfsPath = file.getPath();
if (!SystemInfo.isFileSystemCaseSensitive && !vfsPath.endsWith(vfsSuffixPath) &&
StringUtil.endsWithIgnoreCase(vfsPath, vfsSuffixPath)) {
String realSuffixPath = vfsPath.substring(vfsPath.length() - vfsSuffixPath.length());
Assert.fail("Please correct case-sensitivity of path to prevent test failure on case-sensitive file systems:\n" +
" path " + suffixPath + "\n" +
"real path " + realSuffixPath);
}
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/KtMockFileTypeManager.java
+178
View File
@@ -0,0 +1,178 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.mock.*;
import com.intellij.openapi.fileTypes.*;
import com.intellij.openapi.fileTypes.MockLanguageFileType;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.ArrayUtil;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.test.testFramework.mock.KtMockLanguageFileType;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
public class KtMockFileTypeManager extends FileTypeManager {
private final FileType fileType;
public KtMockFileTypeManager(FileType fileType) {
this.fileType = fileType;
}
@Override
@NotNull
public String getIgnoredFilesList() {
throw new IncorrectOperationException();
}
@Override
public void setIgnoredFilesList(@NotNull String list) {
}
public void save() {
}
@NotNull
public String getExtension(@NotNull String fileName) {
return "";
}
@Override
public void registerFileType(@NotNull FileType type, @NotNull List<FileNameMatcher> defaultAssociations) {
}
@Override
@NotNull
public FileType getFileTypeByFileName(@NotNull String fileName) {
return fileType;
}
@Override
@NotNull
public FileType getFileTypeByFile(@NotNull VirtualFile file) {
return fileType;
}
@Override
@NotNull
public FileType getFileTypeByExtension(@NotNull String extension) {
return fileType;
}
@Override
@NotNull
public FileType[] getRegisteredFileTypes() {
return FileType.EMPTY_ARRAY;
}
@Override
public boolean isFileIgnored(@NotNull String name) {
return false;
}
@Override
public boolean isFileIgnored(@NotNull VirtualFile file) {
return false;
}
@Override
@NotNull
public String[] getAssociatedExtensions(@NotNull FileType type) {
return ArrayUtil.EMPTY_STRING_ARRAY;
}
@Override
public void addFileTypeListener(@NotNull FileTypeListener listener) {
}
@Override
public void removeFileTypeListener(@NotNull FileTypeListener listener) {
}
@Override
public FileType getKnownFileTypeOrAssociate(@NotNull VirtualFile file) {
return file.getFileType();
}
@Override
public FileType getKnownFileTypeOrAssociate(@NotNull VirtualFile file, @NotNull Project project) {
return getKnownFileTypeOrAssociate(file);
}
@Override
@NotNull
public List<FileNameMatcher> getAssociations(@NotNull FileType type) {
return Collections.emptyList();
}
@Override
public void associate(@NotNull FileType type, @NotNull FileNameMatcher matcher) {
}
@Override
public void removeAssociation(@NotNull FileType type, @NotNull FileNameMatcher matcher) {
}
@Override
@NotNull
public FileType getStdFileType(@NotNull @NonNls final String fileTypeName) {
if ("ARCHIVE".equals(fileTypeName) || "CLASS".equals(fileTypeName)) return UnknownFileType.INSTANCE;
if ("PLAIN_TEXT".equals(fileTypeName)) return PlainTextFileType.INSTANCE;
if ("JAVA".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.JavaFileType", fileTypeName);
if ("XML".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.XmlFileType", fileTypeName);
if ("DTD".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.DTDFileType", fileTypeName);
if ("JSP".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.NewJspFileType", fileTypeName);
if ("JSPX".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.JspxFileType", fileTypeName);
if ("HTML".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.HtmlFileType", fileTypeName);
if ("XHTML".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.ide.highlighter.XHtmlFileType", fileTypeName);
if ("JavaScript".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.lang.javascript.JavaScriptFileType", fileTypeName);
if ("Properties".equals(fileTypeName)) return loadFileTypeSafe("com.intellij.lang.properties.PropertiesFileType", fileTypeName);
return new KtMockLanguageFileType(PlainTextLanguage.INSTANCE, fileTypeName.toLowerCase());
}
private static FileType loadFileTypeSafe(final String className, String fileTypeName) {
try {
return (FileType)Class.forName(className).getField("INSTANCE").get(null);
}
catch (Exception ignored) {
return new KtMockLanguageFileType(PlainTextLanguage.INSTANCE, fileTypeName.toLowerCase(Locale.ENGLISH));
}
}
@Override
public boolean isFileOfType(@NotNull VirtualFile file, @NotNull FileType type) {
return false;
}
@NotNull
@Override
public FileType detectFileTypeFromContent(@NotNull VirtualFile file) {
return UnknownFileType.INSTANCE;
}
@Nullable
@Override
public FileType findFileTypeByName(@NotNull String fileTypeName) {
return null;
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/KtMockLanguageFileType.java
+60
View File
@@ -0,0 +1,60 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.lang.Language;
import com.intellij.openapi.fileTypes.LanguageFileType;
import com.sun.istack.internal.NotNull;
import javax.swing.*;
public class KtMockLanguageFileType extends LanguageFileType {
private final String myExtension;
public KtMockLanguageFileType(@NotNull Language language, String extension) {
super(language);
this.myExtension = extension;
}
@NotNull
public String getName() {
return this.getLanguage().getID();
}
@NotNull
public String getDescription() {
return "";
}
@NotNull
public String getDefaultExtension() {
String var10000 = this.myExtension;
if(this.myExtension == null) {
throw new IllegalStateException(String.format("@NotNull method %s.%s must not return null", new Object[]{"com/intellij/mock/KtMockLanguageFileType", "getDefaultExtension"}));
} else {
return var10000;
}
}
public Icon getIcon() {
return null;
}
public boolean equals(Object obj) {
return !(obj instanceof LanguageFileType)?false:this.getLanguage().equals(((LanguageFileType)obj).getLanguage());
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/MockEditorEventMulticaster.java
+94
View File
@@ -0,0 +1,94 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.editor.event.*;
import org.jetbrains.annotations.NotNull;
public class MockEditorEventMulticaster implements EditorEventMulticaster {
public MockEditorEventMulticaster() {
}
@Override
public void addDocumentListener(@NotNull DocumentListener listener) {
}
@Override
public void addDocumentListener(@NotNull DocumentListener listener, @NotNull Disposable parentDisposable) {
}
@Override
public void removeDocumentListener(@NotNull DocumentListener listener) {
}
@Override
public void addEditorMouseListener(@NotNull EditorMouseListener listener) {
}
@Override
public void addEditorMouseListener(@NotNull final EditorMouseListener listener, @NotNull final Disposable parentDisposable) {
}
@Override
public void removeEditorMouseListener(@NotNull EditorMouseListener listener) {
}
@Override
public void addEditorMouseMotionListener(@NotNull EditorMouseMotionListener listener) {
}
@Override
public void addEditorMouseMotionListener(@NotNull EditorMouseMotionListener listener, @NotNull Disposable parentDisposable) {
}
@Override
public void removeEditorMouseMotionListener(@NotNull EditorMouseMotionListener listener) {
}
@Override
public void addCaretListener(@NotNull CaretListener listener) {
}
@Override
public void addCaretListener(@NotNull CaretListener listener, @NotNull Disposable parentDisposable) {
}
@Override
public void removeCaretListener(@NotNull CaretListener listener) {
}
@Override
public void addSelectionListener(@NotNull SelectionListener listener) {
}
@Override
public void addSelectionListener(@NotNull SelectionListener listener, @NotNull Disposable parentDisposable) {
}
@Override
public void removeSelectionListener(@NotNull SelectionListener listener) {
}
@Override
public void addVisibleAreaListener(@NotNull VisibleAreaListener listener) {
}
@Override
public void removeVisibleAreaListener(@NotNull VisibleAreaListener listener) {
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/MockEditorFactory.java
+122
View File
@@ -0,0 +1,122 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.EditorFactory;
import com.intellij.openapi.editor.event.EditorEventMulticaster;
import com.intellij.openapi.editor.event.EditorFactoryListener;
import com.intellij.openapi.editor.impl.DocumentImpl;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.text.CharArrayCharSequence;
import org.jetbrains.annotations.NotNull;
public class MockEditorFactory extends EditorFactory {
public Document createDocument(String text) {
return new DocumentImpl(text);
}
@Override
public Editor createEditor(@NotNull Document document) {
return null;
}
@Override
public Editor createViewer(@NotNull Document document) {
return null;
}
@Override
public Editor createEditor(@NotNull Document document, Project project) {
return null;
}
@Override
public Editor createEditor(@NotNull Document document, Project project, @NotNull VirtualFile file, boolean isViewer) {
return null;
}
@Override
public Editor createEditor(@NotNull final Document document, final Project project, @NotNull final FileType fileType, final boolean isViewer) {
return null;
}
@Override
public Editor createViewer(@NotNull Document document, Project project) {
return null;
}
@Override
public void releaseEditor(@NotNull Editor editor) {
}
@Override
@NotNull
public Editor[] getEditors(@NotNull Document document, Project project) {
return Editor.EMPTY_ARRAY;
}
@Override
@NotNull
public Editor[] getEditors(@NotNull Document document) {
return getEditors(document, null);
}
@Override
@NotNull
public Editor[] getAllEditors() {
return Editor.EMPTY_ARRAY;
}
@Override
public void addEditorFactoryListener(@NotNull EditorFactoryListener listener) {
}
@Override
public void addEditorFactoryListener(@NotNull EditorFactoryListener listener, @NotNull Disposable parentDisposable) {
}
@Override
public void removeEditorFactoryListener(@NotNull EditorFactoryListener listener) {
}
@Override
@NotNull
public EditorEventMulticaster getEventMulticaster() {
return new MockEditorEventMulticaster();
}
@Override
@NotNull
public Document createDocument(@NotNull CharSequence text) {
return new DocumentImpl(text);
}
@Override
@NotNull
public Document createDocument(@NotNull char[] text) {
return createDocument(new CharArrayCharSequence(text));
}
@Override
public void refreshAllEditors() {
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/MockFileManager.java
+107
View File
@@ -0,0 +1,107 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.FileViewProvider;
import com.intellij.psi.PsiDirectory;
import com.intellij.psi.PsiFile;
import com.intellij.psi.SingleRootFileViewProvider;
import com.intellij.psi.impl.PsiManagerEx;
import com.intellij.psi.impl.file.impl.FileManager;
import com.intellij.util.containers.WeakFactoryMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class MockFileManager implements FileManager {
private final PsiManagerEx myManager;
// in mock tests it's LightVirtualFile, they're only alive when they're referenced,
// and there can not be several instances representing the same file
private final WeakFactoryMap<VirtualFile, FileViewProvider> myViewProviders = new WeakFactoryMap<VirtualFile, FileViewProvider>() {
@Override
protected FileViewProvider create(VirtualFile key) {
return new SingleRootFileViewProvider(myManager, key);
}
};
@Override
@NotNull
public FileViewProvider createFileViewProvider(@NotNull VirtualFile file, boolean eventSystemEnabled) {
return new SingleRootFileViewProvider(myManager, file, eventSystemEnabled);
}
public MockFileManager(PsiManagerEx manager) {
myManager = manager;
}
@Override
public void dispose() {
throw new UnsupportedOperationException("Method dispose is not yet implemented in " + getClass().getName());
}
@Override
@Nullable
public PsiFile findFile(@NotNull VirtualFile vFile) {
return getCachedPsiFile(vFile);
}
@Override
@Nullable
public PsiDirectory findDirectory(@NotNull VirtualFile vFile) {
throw new UnsupportedOperationException("Method findDirectory is not yet implemented in " + getClass().getName());
}
@Override
public void reloadFromDisk(@NotNull PsiFile file) //Q: move to PsiFile(Impl)?
{
throw new UnsupportedOperationException("Method reloadFromDisk is not yet implemented in " + getClass().getName());
}
@Override
@Nullable
public PsiFile getCachedPsiFile(@NotNull VirtualFile vFile) {
FileViewProvider provider = findCachedViewProvider(vFile);
return provider.getPsi(provider.getBaseLanguage());
}
@Override
public void cleanupForNextTest() {
myViewProviders.clear();
}
@Override
public FileViewProvider findViewProvider(@NotNull VirtualFile file) {
throw new UnsupportedOperationException("Method findViewProvider is not yet implemented in " + getClass().getName());
}
@Override
public FileViewProvider findCachedViewProvider(@NotNull VirtualFile file) {
return myViewProviders.get(file);
}
@Override
public void setViewProvider(@NotNull VirtualFile virtualFile, FileViewProvider fileViewProvider) {
myViewProviders.put(virtualFile, fileViewProvider);
}
@Override
@NotNull
public List<PsiFile> getAllCachedFiles() {
throw new UnsupportedOperationException("Method getAllCachedFiles is not yet implemented in " + getClass().getName());
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/MockPsiDocumentManager.java
+146
View File
@@ -0,0 +1,146 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.util.Computable;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiDocumentManager;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Collection;
public class MockPsiDocumentManager extends PsiDocumentManager {
@Override
@Nullable
public PsiFile getPsiFile(@NotNull Document document) {
throw new UnsupportedOperationException("Method getPsiFile is not yet implemented in " + getClass().getName());
}
@Override
@Nullable
public PsiFile getCachedPsiFile(@NotNull Document document) {
throw new UnsupportedOperationException("Method getCachedPsiFile is not yet implemented in " + getClass().getName());
}
@Override
@Nullable
public Document getDocument(@NotNull PsiFile file) {
return null;
}
@Override
@Nullable
public Document getCachedDocument(@NotNull PsiFile file) {
VirtualFile vFile = file.getViewProvider().getVirtualFile();
return FileDocumentManager.getInstance().getCachedDocument(vFile);
}
@Override
public void commitAllDocuments() {
}
@Override
public void performForCommittedDocument(@NotNull final Document document, @NotNull final Runnable action) {
action.run();
}
@Override
public void commitDocument(@NotNull Document document) {
}
@NotNull
@Override
public CharSequence getLastCommittedText(@NotNull Document document) {
return document.getImmutableCharSequence();
}
@Override
public long getLastCommittedStamp(@NotNull Document document) {
return document.getModificationStamp();
}
@Nullable
@Override
public Document getLastCommittedDocument(@NotNull PsiFile file) {
return null;
}
@Override
@NotNull
public Document[] getUncommittedDocuments() {
throw new UnsupportedOperationException("Method getUncommittedDocuments is not yet implemented in " + getClass().getName());
}
@Override
public boolean isUncommited(@NotNull Document document) {
throw new UnsupportedOperationException("Method isUncommited is not yet implemented in " + getClass().getName());
}
@Override
public boolean isCommitted(@NotNull Document document) {
throw new UnsupportedOperationException();
}
@Override
public boolean hasUncommitedDocuments() {
throw new UnsupportedOperationException("Method hasUncommitedDocuments is not yet implemented in " + getClass().getName());
}
@Override
public void commitAndRunReadAction(@NotNull Runnable runnable) {
throw new UnsupportedOperationException("Method commitAndRunReadAction is not yet implemented in " + getClass().getName());
}
@Override
public <T> T commitAndRunReadAction(@NotNull Computable<T> computation) {
throw new UnsupportedOperationException("Method commitAndRunReadAction is not yet implemented in " + getClass().getName());
}
@Override
public void addListener(@NotNull Listener listener) {
throw new UnsupportedOperationException("Method addListener is not yet implemented in " + getClass().getName());
}
@Override
public void removeListener(@NotNull Listener listener) {
throw new UnsupportedOperationException("Method removeListener is not yet implemented in " + getClass().getName());
}
@Override
public boolean isDocumentBlockedByPsi(@NotNull Document doc) {
throw new UnsupportedOperationException("Method isDocumentBlockedByPsi is not yet implemented in " + getClass().getName());
}
@Override
public void doPostponedOperationsAndUnblockDocument(@NotNull Document doc) {
throw new UnsupportedOperationException(
"Method doPostponedOperationsAndUnblockDocument is not yet implemented in " + getClass().getName());
}
@Override
public boolean performWhenAllCommitted(@NotNull Runnable action) {
throw new UnsupportedOperationException();
}
@Override
public void reparseFiles(@NotNull Collection<VirtualFile> files, boolean includeOpenFiles) {
throw new UnsupportedOperationException();
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/MockPsiManager.java
+188
View File
@@ -0,0 +1,188 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Comparing;
import com.intellij.openapi.util.Key;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.*;
import com.intellij.psi.impl.PsiManagerEx;
import com.intellij.psi.impl.PsiModificationTrackerImpl;
import com.intellij.psi.impl.PsiTreeChangeEventImpl;
import com.intellij.psi.impl.file.impl.FileManager;
import com.intellij.psi.util.PsiModificationTracker;
import gnu.trove.THashMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Map;
public class MockPsiManager extends PsiManagerEx {
private final Project myProject;
private final Map<VirtualFile,PsiDirectory> myDirectories = new THashMap<VirtualFile, PsiDirectory>();
private MockFileManager myMockFileManager;
private PsiModificationTrackerImpl myPsiModificationTracker;
public MockPsiManager(@NotNull Project project) {
myProject = project;
}
public void addPsiDirectory(VirtualFile file, PsiDirectory psiDirectory) {
myDirectories.put(file, psiDirectory);
}
@Override
@NotNull
public Project getProject() {
return myProject;
}
@Override
public PsiFile findFile(@NotNull VirtualFile file) {
return null;
}
@Override
@Nullable
public
FileViewProvider findViewProvider(@NotNull VirtualFile file) {
return null;
}
@Override
public PsiDirectory findDirectory(@NotNull VirtualFile file) {
return myDirectories.get(file);
}
@Override
public boolean areElementsEquivalent(PsiElement element1, PsiElement element2) {
return Comparing.equal(element1, element2);
}
@Override
public void reloadFromDisk(@NotNull PsiFile file) {
}
@Override
public void addPsiTreeChangeListener(@NotNull PsiTreeChangeListener listener) {
}
@Override
public void addPsiTreeChangeListener(@NotNull PsiTreeChangeListener listener, @NotNull Disposable parentDisposable) {
}
@Override
public void removePsiTreeChangeListener(@NotNull PsiTreeChangeListener listener) {
}
@Override
@NotNull
public PsiModificationTracker getModificationTracker() {
if (myPsiModificationTracker == null) {
myPsiModificationTracker = new PsiModificationTrackerImpl(myProject);
}
return myPsiModificationTracker;
}
@Override
public void startBatchFilesProcessingMode() {
}
@Override
public void finishBatchFilesProcessingMode() {
}
@Override
public <T> T getUserData(@NotNull Key<T> key) {
return null;
}
@Override
public <T> void putUserData(@NotNull Key<T> key, T value) {
}
@Override
public boolean isDisposed() {
return false;
}
@Override
public void dropResolveCaches() {
getFileManager().cleanupForNextTest();
}
@Override
public boolean isInProject(@NotNull PsiElement element) {
return false;
}
@Override
public boolean isBatchFilesProcessingMode() {
return false;
}
@Override
public boolean isAssertOnFileLoading(@NotNull VirtualFile file) {
return false;
}
@Override
public void beforeChange(boolean isPhysical) {
throw new UnsupportedOperationException();
}
@Override
public void afterChange(boolean isPhysical) {
throw new UnsupportedOperationException();
}
@Override
public void registerRunnableToRunOnChange(@NotNull Runnable runnable) {
}
@Override
public void registerRunnableToRunOnAnyChange(@NotNull Runnable runnable) {
}
@Override
public void registerRunnableToRunAfterAnyChange(@NotNull Runnable runnable) {
throw new UnsupportedOperationException("Method registerRunnableToRunAfterAnyChange is not yet implemented in " + getClass().getName());
}
@Override
@NotNull
public FileManager getFileManager() {
if (myMockFileManager == null) {
myMockFileManager = new MockFileManager(this);
}
return myMockFileManager;
}
@Override
public void beforeChildRemoval(@NotNull final PsiTreeChangeEventImpl event) {
}
@Override
public void beforeChildReplacement(@NotNull final PsiTreeChangeEventImpl event) {
}
@Override
public void beforeChildAddition(@NotNull PsiTreeChangeEventImpl event) {
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/MockSchemesManagerFactory.java
+33
View File
@@ -0,0 +1,33 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.components.RoamingType;
import com.intellij.openapi.options.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class MockSchemesManagerFactory extends SchemesManagerFactory {
private static final SchemesManager EMPTY = new EmptySchemesManager();
@Override
protected <T extends Scheme, E extends ExternalizableScheme> SchemesManager<T, E> create(@NotNull String directoryName,
@NotNull SchemeProcessor<E> processor,
@NotNull RoamingType roamingType,
@Nullable String presentableName) {
return EMPTY;
}
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/mock/PsiManagerEx.java
+53
View File
@@ -0,0 +1,53 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework.mock;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiManager;
import com.intellij.psi.impl.PsiTreeChangeEventImpl;
import com.intellij.psi.impl.file.impl.FileManager;
import org.jetbrains.annotations.NotNull;
public abstract class PsiManagerEx extends PsiManager {
public abstract boolean isBatchFilesProcessingMode();
public abstract boolean isAssertOnFileLoading(@NotNull VirtualFile file);
/**
* @param runnable to be run before <b>physical</b> PSI change
*/
public abstract void registerRunnableToRunOnChange(@NotNull Runnable runnable);
/**
* @param runnable to be run before <b>physical</b> or <b>non-physical</b> PSI change
*/
public abstract void registerRunnableToRunOnAnyChange(@NotNull Runnable runnable);
public abstract void registerRunnableToRunAfterAnyChange(@NotNull Runnable runnable);
@NotNull
public abstract FileManager getFileManager();
public abstract void beforeChildAddition(@NotNull PsiTreeChangeEventImpl event);
public abstract void beforeChildRemoval(@NotNull PsiTreeChangeEventImpl event);
public abstract void beforeChildReplacement(@NotNull PsiTreeChangeEventImpl event);
public abstract void beforeChange(boolean isPhysical);
public abstract void afterChange(boolean isPhysical);
}
compiler/tests/org/jetbrains/kotlin/test/testFramework/util.kt
+37
View File
@@ -0,0 +1,37 @@
/*
* Copyright 2010-2016 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.kotlin.test.testFramework
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.components.ComponentManager
import com.intellij.openapi.vfs.VirtualFile
import org.picocontainer.MutablePicoContainer
fun <T> ComponentManager.registerServiceInstance(interfaceClass: Class<T>, instance: T) {
val picoContainer = picoContainer as MutablePicoContainer
val key = interfaceClass.name
picoContainer.unregisterComponent(key)
picoContainer.registerComponentInstance(key, instance)
}
fun deleteFile(file: VirtualFile) {
runInEdtAndWait { runWriteAction { file.delete(null) } }
}
fun <T> runWriteAction(action: () -> T): T {
return ApplicationManager.getApplication().runWriteAction<T>(action)
}
idea/idea.iml
+1 -1
View File
@@ -20,7 +20,6 @@
<orderEntry type="module" module-name="backend" />
<orderEntry type="module" module-name="frontend" />
<orderEntry type="module" module-name="frontend.java" />
<orderEntry type="module" module-name="compiler-tests" scope="TEST" />
<orderEntry type="module" module-name="light-classes" />
<orderEntry type="module" module-name="cli-common" />
<orderEntry type="library" name="idea-full" level="project" />
@@ -50,6 +49,7 @@
<orderEntry type="module" module-name="daemon-client" />
<orderEntry type="module" module-name="idea-repl" scope="TEST" />
<orderEntry type="module" module-name="idea-live-templates" exported="" scope="RUNTIME" />
<orderEntry type="module" module-name="compiler-tests" scope="TEST" />
<orderEntry type="library" scope="TEST" name="kotlin-test" level="project" />
</component>
</module>
plugins/plugins-tests/tests/org/jetbrains/kotlin/lang/resolve/android/test/AbstractAndroidSyntheticPropertyDescriptorTest.kt
+2 -1
View File
@@ -28,9 +28,10 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager
import org.jetbrains.kotlin.test.ConfigurationKind
import org.jetbrains.kotlin.test.KotlinTestUtils
import org.jetbrains.kotlin.test.TestJdkKind
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import java.io.File
abstract class AbstractAndroidSyntheticPropertyDescriptorTest : UsefulTestCase() {
abstract class AbstractAndroidSyntheticPropertyDescriptorTest : KtUsefulTestCase() {
fun doTest(path: String) {
val config = KotlinTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.ANDROID_API)
plugins/plugins-tests/tests/org/jetbrains/kotlin/lang/resolve/android/test/CompilerTestUtils.kt
+2 -2
View File
@@ -16,7 +16,6 @@
package org.jetbrains.kotlin.lang.resolve.android.test
import com.intellij.testFramework.UsefulTestCase
import com.intellij.testFramework.registerServiceInstance
import org.jetbrains.kotlin.android.synthetic.AndroidConfigurationKeys
import org.jetbrains.kotlin.android.synthetic.AndroidExtensionPropertiesComponentContainerContributor
@@ -33,9 +32,10 @@ import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
import java.io.File
fun UsefulTestCase.createAndroidTestEnvironment(configuration: CompilerConfiguration, resDirectories: List<String>): KotlinCoreEnvironment {
fun KtUsefulTestCase.createAndroidTestEnvironment(configuration: CompilerConfiguration, resDirectories: List<String>): KotlinCoreEnvironment {
configuration.put(AndroidConfigurationKeys.VARIANT, resDirectories)
configuration.put(AndroidConfigurationKeys.PACKAGE, "test")
temp-jdk8/temp-jdk8.iml
-11
View File
@@ -1,11 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>
update_dependencies.xml
+9
View File
@@ -747,6 +747,15 @@
<delete dir="@{download.dir}"/>
<mkdir dir="@{download.dir}"/>
<!-- For running compiler tests with Java 1.6 -->
<get src="@{base.repository.url}/ideaIC/15.0.5/ideaIC-15.0.5.zip" dest="@{download.dir}/ideaIC-15.0.5.zip" usetimestamp="true"/>
<unzip src="@{download.dir}/ideaIC-15.0.5.zip" dest="@{download.dir}/idea-15-for-tests">
<patternset>
<include name="**/lib/openapi.jar"/>
<include name="**/lib/idea_rt.jar"/>
</patternset>
</unzip>
<property name="idea.id" value="idea${sdk.version.prefix}"/>
<get src="@{base.repository.url}/ideaIC/@{idea.maven.version}/ideaIC-@{idea.maven.version}-sources.jar"